Trace Call Tree - npmean.trace

C:\Users\Prakash\Documents\jobsearch\grimoire\experiments\python\npmean.trace
File events: 223156 | Nodes: 39564 | Max depth: 13
debugnpmean.py (1)
 import numpy as np (1)
<frozen importlib._bootstrap> (1) (102)
 (102)
 (204)
 (102)
 (102)
 (102)
 (376)
 (376)
 (376)
 (376)
 (101)
 (101)
 (376)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (376)
 (376)
 (102)
 (376)
 (752)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (752)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (376)
 (102)
 (102)
 (102)
 (102)
 (102)
 (102)
 (102)
 (101)
 (101)
 (101)
 (101)
 (101)
 (397)
 (792)
 (396)
 (396)
 (396)
 (396)
__init__.py (101) if path is not None and not fullname.startswith('test.'): (101)
 method_name = 'spec_for_{fullname}'.format(**locals()) (15)
 method = getattr(self, method_name, lambda: None) (30)
 return method() (15)
 return None (86)

<frozen importlib._bootstrap_external> (97) (97)
 (11)
 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (11)
 (11)
 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (131)
<frozen zipimport> (8) (8)
 (8)

 (97)
 (97)
 (97)
 (97)
 (97)
 (97)
 (91)
 (91)
 (91)
 (115)
 (115)
 (115)
 (115)
 (345)
 (230)
 (115)
 (115)
 (115)
 (115)
 (115)
 (345)
 (115)
 (115)
 (91)
 (8)
 (8)
 (8)
 (16)
 (16)
 (16)
<frozen zipimport> (8) (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)

 (8)
 (8)
 (8)
 (8)
 (8)
 (26)
 (26)
 (14)
 (8)
 (8)
 (32)
 (88)
 (8)
 (8)
 (8)
 (14)
 (14)
 (14)
 (14)
 (14)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (8)
 (234)
 (226)
 (226)
 (36)
 (226)
 (190)
 (8)
 (8)
 (234)
 (8)
 (6)
 (18)
 (18)
 (18)
 (18)
 (18)
 (12)
 (12)
 (6)
 (6)
 (6)
 (6)
 (12)
 (6)
 (6)
 (6)
 (6)
 (6)
 (6)

 (396)
 (396)
 (101)
 (97)
 (97)
 (248)
__init__.py (8) """ (8)
 def _delvewheel_patch_1_10_0(): (1)
 _delvewheel_patch_1_10_0() (1)
 import os (1)
 if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'numpy.libs'))): (1)
<frozen ntpath> (1) (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (12)
 (11)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (3)
 (2)
 (2)
 (2)
 (2)
 (2)
 (2)
 (1)
 (1)
 (1)
 (1)

 os.add_dll_directory(libs_dir) (1)
<frozen os> (1) (1)
 (1)
 (2)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)

 del _delvewheel_patch_1_10_0 (1)
 import os (1)
 import sys (1)
 import warnings (1)
 from ._globals import _NoValue, _CopyMode (1)
 import functools (2)
 import warnings (1)
 from ._convertions import asunicode, asbytes (2)
 import os (1)
 env_added = [] (1)
 for envkey in ['OPENBLAS_MAIN_FREE', 'GOTOBLAS_MAIN_FREE']: (3)
 if envkey not in os.environ: (2)
<frozen _collections_abc> (2) (2)
 (2)
<frozen os> (2) (2)
 (2)
 (2)
 (2)
 (2)
 (2)
 (2)

 (2)
 (2)

 os.environ[envkey] = '1' (2)
<frozen os> (2) (2)
 (2)
 (4)
 (4)
 (2)
 (2)
 (2)

 env_added.append(envkey) (2)
 try: (1)
 from . import multiarray (1)
 import os as _os, sys as _sys (2)
 import types as _types (2)
 __version__ = "1.1.0" (1)
 from _ctypes import Union, Structure, Array (1)
 from . import linalg  # deprecated in NumPy 2.0 (1)

_globals.py (1) """ (1)
 import enum (1)
 from ._utils import set_module as _set_module (1)

_convertions.py (1) """ (1)
 __all__ = ["asunicode", "asbytes"] (1)
 def asunicode(s): (1)
 def asbytes(s): (1)

_expired_attrs_2_0.py (1) """ (1)
 __expired_attributes__ = { (53)
 "geterrobj": "Use the np.errstate context manager instead.", (1)
 "seterrobj": "Use the np.errstate context manager instead.", (1)
 "cast": "Use `np.asarray(arr, dtype=dtype)` instead.", (1)
 "source": "Use `inspect.getsource` instead.", (1)
 "lookfor":  "Search NumPy's documentation directly.", (1)
 "who": "Use an IDE variable explorer or `locals()` instead.", (1)
 "fastCopyAndTranspose": "Use `arr.T.copy()` instead.", (1)
 "set_numeric_ops": (1)
 "For the general case, use `PyUFunc_ReplaceLoopBySignature`. " (1)
 "NINF": "Use `-np.inf` instead.", (1)
 "PINF": "Use `np.inf` instead.", (1)
 "NZERO": "Use `-0.0` instead.", (1)
 "PZERO": "Use `0.0` instead.", (1)
 "add_newdoc": (1)
 "It's still available as `np.lib.add_newdoc`.", (1)
 "add_docstring": (1)
 "It's still available as `np.lib.add_docstring`.", (1)
 "add_newdoc_ufunc": (1)
 "It's an internal function and doesn't have a replacement.", (1)
 "compat": "There's no replacement, as Python 2 is no longer supported.", (1)
 "safe_eval": "Use `ast.literal_eval` instead.", (1)
 "float_": "Use `np.float64` instead.", (1)
 "complex_": "Use `np.complex128` instead.", (1)
 "longfloat": "Use `np.longdouble` instead.", (1)
 "singlecomplex": "Use `np.complex64` instead.", (1)
 "cfloat": "Use `np.complex128` instead.", (1)
 "longcomplex": "Use `np.clongdouble` instead.", (1)
 "clongfloat": "Use `np.clongdouble` instead.", (1)
 "string_": "Use `np.bytes_` instead.", (1)
 "unicode_": "Use `np.str_` instead.", (1)
 "Inf": "Use `np.inf` instead.", (1)
 "Infinity": "Use `np.inf` instead.", (1)
 "NaN": "Use `np.nan` instead.", (1)
 "infty": "Use `np.inf` instead.", (1)
 "issctype": "Use `issubclass(rep, np.generic)` instead.", (1)
 "maximum_sctype": (1)
 "Use a specific dtype instead. You should avoid relying " (1)
 "obj2sctype": "Use `np.dtype(obj).type` instead.", (1)
 "sctype2char": "Use `np.dtype(obj).char` instead.", (1)
 "sctypes": "Access dtypes explicitly instead.", (1)
 "issubsctype": "Use `np.issubdtype` instead.", (1)
 "set_string_function": (1)
 "Use `np.set_printoptions` instead with a formatter for " (1)
 "asfarray": "Use `np.asarray` with a proper dtype instead.", (1)
 "issubclass_": "Use `issubclass` builtin instead.", (1)
 "tracemalloc_domain": "It's now available from `np.lib`.", (1)
 "mat": "Use `np.asmatrix` instead.", (1)
 "recfromcsv": "Use `np.genfromtxt` with comma delimiter instead.", (1)
 "recfromtxt": "Use `np.genfromtxt` instead.", (1)
 "deprecate": "Emit `DeprecationWarning` with `warnings.warn` directly, " (1)
 "deprecate_with_doc": "Emit `DeprecationWarning` with `warnings.warn` " (1)
 "disp": "Use your own printing function instead.", (1)
 "find_common_type": (1)
 "Use `numpy.promote_types` or `numpy.result_type` instead. " (1)
 "round_": "Use `np.round` instead.", (1)
 "get_array_wrap": "", (1)
 "DataSource": "It's still available as `np.lib.npyio.DataSource`.", (1)
 "nbytes": "Use `np.dtype(<dtype>).itemsize` instead.", (1)
 "byte_bounds": "Now it's available under `np.lib.array_utils.byte_bounds`", (1)
 "It's still available as `np.char.compare_chararrays`.", (1)
 "format_parser": "It's still available as `np.rec.format_parser`.", (1)
 "alltrue": "Use `np.all` instead.", (1)
 "sometrue": "Use `np.any` instead.", (1)

version.py (1) """ (1)
 version = "2.2.3" (1)
 __version__ = version (1)
 full_version = version (1)
 git_revision = "a27456108104ac11e8564c2f18710997f3a55eb9" (1)
 release = 'dev' not in version and '+' not in version (1)
 short_version = version.split("+")[0] (1)

_distributor_init.py (1) """ Distributor init file (1)
 try: (1)
 from . import _distributor_init_local (1)

__config__.py (1) from enum import Enum (1)
 from numpy._core._multiarray_umath import ( (1)

multiarray.py (1) """ (1)
 import functools (1)
 from . import overrides (1)

overrides.py (1) """Implementation of __array_function__ overrides from NEP-18.""" (1)
 import collections (1)
 import functools (1)
 from .._utils import set_module (1)

_inspect.py (1) """Subset of inspect module from upstream python (1)
 import types (1)
 __all__ = ['getargspec', 'formatargspec'] (1)
 def ismethod(object): (1)
 def isfunction(object): (1)
 def iscode(object): (1)
 CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8 (1)
 def getargs(co): (1)
 def getargspec(func): (1)
 def getargvalues(frame): (1)
 def joinseq(seq): (1)
 def strseq(object, convert, join=joinseq): (1)
 def formatargspec(args, varargs=None, varkw=None, defaults=None, (2)
 formatarg=str, (1)
 formatvarargs=lambda name: '*' + name, (1)
 formatvarkw=lambda name: '**' + name, (1)
 formatvalue=lambda value: '=' + repr(value), (1)
 join=joinseq): (1)
 formatarg=str, (1)
 formatvarargs=lambda name: '*' + name, (1)
 formatvarkw=lambda name: '**' + name, (1)
 formatvalue=lambda value: '=' + repr(value), (1)
 join=joinseq): (1)
 def formatargvalues(args, varargs, varkw, locals, (1)

datetime.py (1) try: (1)
 from _datetime import * (1)

exceptions.py (1) """ (1)
 __all__ = [ (1)
 if '_is_loaded' in globals(): (1)
 _is_loaded = True (1)
 class ComplexWarning(RuntimeWarning): (2)
 """ (1)
 pass (1)
 class ModuleDeprecationWarning(DeprecationWarning): (2)
 """Module deprecation warning. (1)
 pass (1)
 class VisibleDeprecationWarning(UserWarning): (2)
 """Visible deprecation warning. (1)
 pass (1)
 class RankWarning(RuntimeWarning): (2)
 """Matrix rank warning. (1)
 pass (1)
 class TooHardError(RuntimeError): (2)
 """max_work was exceeded. (1)
 pass (1)
 class AxisError(ValueError, IndexError): (2)
 """Axis supplied was invalid. (1)
 __slots__ = ("axis", "ndim", "_msg") (1)
 def __init__(self, axis, ndim=None, msg_prefix=None): (1)
 def __str__(self): (1)
 class DTypePromotionError(TypeError): (2)
 """Multiple DTypes could not be converted to a common one. (1)
 pass (1)

_exceptions.py (1) """ (1)
 from .._utils import set_module (1)

printoptions.py (1) """ (1)
 import sys (1)
 from contextvars import ContextVar (1)

contextvars.py (1) from _contextvars import Context, ContextVar, Token, copy_context (1)

dtypes.py (1) """ (1)
 __all__ = [] (1)
 def _add_dtype_helper(DType, alias): (1)

<frozen importlib._bootstrap_external> (6) (8)
 (4)
 (4)
 (2)

umath.py (1) """ (1)
 import numpy (1)

numerictypes.py (1) """ (1)
 import numbers (1)

numbers.py (1) """Abstract Base Classes (ABCs) for numbers, according to PEP 3141. (1)
 from abc import ABCMeta, abstractmethod (1)
 __all__ = ["Number", "Complex", "Real", "Rational", "Integral"] (1)
 class Number(metaclass=ABCMeta): (2)
 """All numbers inherit from this class. (1)
 __slots__ = () (1)
 __hash__ = None (1)
<frozen abc> (1) (1)
 (1)
 (1)

 class Complex(Number): (2)
 """Complex defines the operations that work on the builtin complex type. (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __complex__(self): (2)
 def __bool__(self): (1)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def real(self): (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def imag(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __add__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __radd__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __neg__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __pos__(self): (2)
 def __sub__(self, other): (1)
 def __rsub__(self, other): (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __mul__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rmul__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __truediv__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rtruediv__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __pow__(self, exponent): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rpow__(self, base): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __abs__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def conjugate(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __eq__(self, other): (2)
<frozen abc> (1) (1)
 (1)
 (1)

 Complex.register(complex) (1)
<frozen abc> (1) (1)
 (1)

 class Real(Complex): (2)
 """To Complex, Real adds the operations that work on real numbers. (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __float__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __trunc__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __floor__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __ceil__(self): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __round__(self, ndigits=None): (2)
 def __divmod__(self, other): (1)
 def __rdivmod__(self, other): (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __floordiv__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rfloordiv__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __mod__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rmod__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __lt__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __le__(self, other): (2)
 def __complex__(self): (1)
 @property (2)
 def real(self): (2)
 @property (2)
 def imag(self): (2)
 def conjugate(self): (1)
<frozen abc> (1) (1)
 (1)
 (1)

 Real.register(float) (1)
<frozen abc> (1) (1)
 (1)

 class Rational(Real): (2)
 """To Real, Rational adds numerator and denominator properties. (1)
 __slots__ = () (1)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def numerator(self): (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def denominator(self): (2)
 def __float__(self): (1)
<frozen abc> (1) (1)
 (1)
 (1)

 class Integral(Rational): (2)
 """Integral adds methods that work on integral numbers. (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __int__(self): (2)
 def __index__(self): (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __pow__(self, exponent, modulus=None): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __lshift__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rlshift__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rshift__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rrshift__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __and__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rand__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __xor__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __rxor__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __or__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __ror__(self, other): (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __invert__(self): (2)
 def __float__(self): (1)
 @property (2)
 def numerator(self): (2)
 @property (2)
 def denominator(self): (2)
<frozen abc> (1) (1)
 (1)
 (1)

 Integral.register(int) (1)
<frozen abc> (1) (1)
 (1)


_string_helpers.py (1) """ (1)
 _all_chars = tuple(map(chr, range(256))) (1)
 _ascii_upper = _all_chars[65:65+26] (1)
 _ascii_lower = _all_chars[97:97+26] (1)
 LOWER_TABLE = _all_chars[:65] + _ascii_lower + _all_chars[65+26:] (1)
 UPPER_TABLE = _all_chars[:97] + _ascii_upper + _all_chars[97+26:] (1)
 def english_lower(s): (1)
 def english_upper(s): (1)
 def english_capitalize(s): (1)

_type_aliases.py (1) """ (1)
 import numpy._core.multiarray as ma (1)

_dtype.py (1) """ (1)
 import numpy as np (1)

numeric.py (1) import functools (1)
 import itertools (1)
 import operator (1)
 import sys (1)
 import warnings (1)
 import numbers (1)
 import builtins (1)
 import math (1)
 import numpy as np (1)

shape_base.py (1) __all__ = ['atleast_1d', 'atleast_2d', 'atleast_3d', 'block', 'hstack', (1)
 import functools (1)
 import itertools (1)
 import operator (1)
 from . import numeric as _nx (1)

fromnumeric.py (1) """Module containing non-deprecated functions borrowed from Numeric. (1)
 import functools (1)
 import types (1)
 import warnings (1)
 import numpy as np (1)

_methods.py (1) """ (1)
 import os (1)
 import pickle (1)
 import warnings (1)
 from contextlib import nullcontext (1)
 import numpy as np (1)

_ufunc_config.py (1) """ (1)
 import contextlib (1)
 import contextvars (1)
 import functools (1)
 from .._utils import set_module (1)

arrayprint.py (1) """Array printing function (1)
 __all__ = ["array2string", "array_str", "array_repr", (1)
 __docformat__ = 'restructuredtext' (1)
 import functools (1)
 import numbers (1)
 import sys (1)
 try: (1)
 from _thread import get_ident (1)
 import numpy as np (1)

_asarray.py (1) """ (1)
 from .overrides import ( (1)

records.py (1) """ (1)
 import os (1)
 import warnings (1)
 from collections import Counter (1)

memmap.py (1) from contextlib import nullcontext (1)
 import operator (1)
 import numpy as np (1)

function_base.py (1) import functools (1)
 import warnings (1)
 import operator (1)
 import types (1)
 import numpy as np (1)

_machar.py (1) """ (1)
 __all__ = ['MachAr'] (1)
 from .fromnumeric import any (1)

getlimits.py (1) """Machine limits for Float32 and Float64 and (long double) if available... (1)
 __all__ = ['finfo', 'iinfo'] (1)
 import types (1)
 import warnings (1)
 from .._utils import set_module (1)

einsumfunc.py (1) """ (1)
 import itertools (1)
 import operator (1)
 from numpy._core.multiarray import c_einsum (1)
 from numpy._core.numeric import asanyarray, tensordot (1)
 from numpy._core.overrides import array_function_dispatch (1)
 __all__ = ['einsum', 'einsum_path'] (1)
 einsum_symbols = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' (1)
 einsum_symbols_set = set(einsum_symbols) (1)
 def _flop_count(idx_contraction, inner, num_terms, size_dictionary): (1)
 def _compute_size_by_dict(indices, idx_dict): (1)
 def _find_contraction(positions, input_sets, output_set): (1)
 def _optimal_path(input_sets, output_set, idx_dict, memory_limit): (1)
 def _parse_possible_contraction( (1)
 def _update_other_results(results, best): (1)
 def _greedy_path(input_sets, output_set, idx_dict, memory_limit): (1)
 def _can_dot(inputs, result, idx_removed): (1)
 def _parse_einsum_input(operands): (1)
 def _einsum_path_dispatcher(*operands, optimize=None, einsum_call=None): (1)
 @array_function_dispatch(_einsum_path_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def einsum_path(*operands, optimize='greedy', einsum_call=False): (2)
 def _einsum_dispatcher(*operands, out=None, optimize=None, **kwargs): (1)
 @array_function_dispatch(_einsum_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def einsum(*operands, out=None, optimize=False, **kwargs): (2)

_add_newdocs.py (1) """ (1)
 from numpy._core.function_base import add_newdoc (1)
 from numpy._core.overrides import get_array_function_like_doc (1)
 add_newdoc('numpy._core', 'flatiter', (2)
function_base.py (1) new = getattr(__import__(place, globals(), {}, [obj]), obj) (1)

 """ (1)

_add_newdocs_scalars.py (1) """ (1)
 import sys (1)
 import os (1)
 from numpy._core import dtype (1)

_dtype_ctypes.py (1) """ (1)
 import numpy as np (1)

_internal.py (1) """ (1)
 import ast (1)
 import math (1)
 import re (1)
 import sys (1)
 import warnings (1)
 from ..exceptions import DTypePromotionError (1)

_endian.py (1) import sys (1)
 from ctypes import Array, Structure, Union (1)

_pytesttester.py (1) """ (1)
 import sys (1)
 import os (1)
 __all__ = ['PytestTester'] (1)
 def _show_numpy_info(): (1)
 class PytestTester: (2)
 """ (1)
 def __init__(self, module_name): (1)
 def __call__(self, label='fast', verbose=1, extra_argv=None, (2)
 doctests=False, coverage=False, durations=-1, tests=None): (1)

array_utils.py (1) from ._array_utils_impl import ( (1)

_array_utils_impl.py (1) """ (1)
 from numpy._core import asarray (1)

introspect.py (1) """ (1)
 import re (1)
 __all__ = ['opt_func_info'] (1)
 def opt_func_info(func_name=None, signature=None): (1)

mixins.py (1) """ (1)
 from numpy._core import umath as um (1)

npyio.py (1) from ._npyio_impl import ( (1)

_npyio_impl.py (1) """ (1)
 import os (1)
 import re (1)
 import functools (1)
 import itertools (1)
 import warnings (1)
 import weakref (1)
 import contextlib (1)
 import operator (1)
 from operator import itemgetter (1)
 from collections.abc import Mapping (1)
 import pickle (1)
 import numpy as np (1)

format.py (1) """ (1)
 import io (1)
 import os (1)
 import pickle (1)
 import warnings (1)
 import numpy (1)

_utils_impl.py (1) import os (1)
 import sys (1)
 import textwrap (1)

textwrap.py (1) """Text wrapping and filling. (1)
 import re (1)
 __all__ = ['TextWrapper', 'wrap', 'fill', 'dedent', 'indent', 'shorten'] (1)
 _whitespace = '\t\n\x0b\x0c\r ' (1)
 class TextWrapper: (2)
 """ (1)
 unicode_whitespace_trans = dict.fromkeys(map(ord, _whitespace), ord(' ')) (1)
 word_punct = r'[\w!"\'&.,?]' (1)
 letter = r'[^\d\W]' (1)
 whitespace = r'[%s]' % re.escape(_whitespace) (1)
__init__.py (1) if isinstance(pattern, str): (1)
 return pattern.translate(_special_chars_map) (1)

 nowhitespace = '[^' + whitespace[1:] (1)
 wordsep_re = re.compile(r''' (3)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 flags = flags.value (1)
enum.py (1) if instance is None: (1)
 if self.fget is not None: (1)
 return self.fget(instance) (1)
 return self._value_ (1)

 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (449)
 try: (449)
 char = self.decoded_string[index] (449)
 if char == "\\": (448)
 self.index = index + 1 (448)
 self.next = char (448)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (12)
 itemsappend = items.append (12)
 sourcematch = source.match (12)
 start = source.tell() (12)
 return self.index - len(self.next or '') (39)
 while True: (18)
 itemsappend(_parse(source, state, verbose, nested + 1, (36)
 not nested and not items)) (18)
 subpattern = SubPattern(state) (18)
 self.state = state (28)
 if data is None: (28)
 data = [] (22)
 self.data = data (28)
 self.width = None (28)
 subpatternappend = subpattern.append (18)
 sourceget = source.get (18)
 sourcematch = source.match (18)
 _len = len (18)
 _ord = ord (18)
 while True: (251)
 this = source.next (251)
 if this is None: (251)
 if this in "|)": (250)
 sourceget() (233)
 this = self.next (409)
 self.__next() (409)
 return this (409)
 if verbose: (233)
 if this in WHITESPACE: (233)
 continue (190)
 if this == "#": (43)
 if this[0] == "\\": (37)
 elif this not in SPECIAL_CHARS: (34)
 elif this == "[": (27)
 elif this in REPEAT_CHARS: (17)
 elif this == ".": (11)
 elif this == "(": (11)
 start = source.tell() - 1 (11)
 capture = True (11)
 atomic = False (11)
 name = None (11)
 add_flags = 0 (11)
 del_flags = 0 (11)
 if sourcematch("?"): (11)
 if char == self.next: (111)
 return False (72)
 if capture: (3)
 try: (1)
 group = state.opengroup(name) (1)
 gid = self.groups (1)
 return len(self.groupwidths) (6)
 self.groupwidths.append(None) (1)
 if self.groups > MAXGROUPS: (1)
 if name is not None: (1)
 return gid (1)
 sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and (6)
 not (del_flags & SRE_FLAG_VERBOSE)) (3)
 p = _parse_sub(source, state, sub_verbose, nested + 1) (3)
 while True: (105)
 this = sourceget() (105)
 if this is None or this == "\n": (105)
 break (6)
 continue (6)
 index += 1 (35)
 try: (35)
 char += self.decoded_string[index] (35)
 here = source.tell() - 1 (10)
 set = [] (10)
 setappend = set.append (10)
 if source.next == '[': (10)
 negate = sourcematch("^") (10)
 while True: (54)
 this = sourceget() (54)
 if this is None: (54)
 if this == "]" and set: (54)
 elif this[0] == "\\": (44)
 code1 = _class_escape(source, this) (32)
 code = ESCAPES.get(escape) (32)
 if code: (32)
 code = CATEGORIES.get(escape) (32)
 if code and code[0] is IN: (32)
 try: (20)
 c = escape[1:2] (20)
 if c == "x": (20)
 elif c == "u" and source.istext: (20)
 elif c == "U" and source.istext: (20)
 elif c == "N" and source.istext: (20)
 elif c in OCTDIGITS: (20)
 elif c in DIGITS: (20)
 if len(escape) == 2: (20)
 if c in ASCIILETTERS: (20)
 return LITERAL, ord(escape[1]) (20)
 if sourcematch("-"): (44)
 if code1[0] is IN: (44)
 setappend(code1) (44)
 break (10)
 set = _uniq(set) (10)
 return list(dict.fromkeys(items)) (10)
 if _len(set) == 1 and set[0][0] is LITERAL: (10)
 if negate: (10)
 subpatternappend((IN, set)) (10)
 self.data.append(code) (35)
 here = source.tell() (6)
 if this == "?": (6)
 elif this == "*": (5)
 elif this == "+": (5)
 min, max = 1, MAXREPEAT (2)
 if subpattern: (6)
 return len(self.data) (45)
 item = subpattern[-1:] (6)
 if isinstance(index, slice): (71)
 return SubPattern(self.state, self.data[index]) (6)
 if not item or item[0][0] is AT: (6)
 return self.data[index] (65)
 if item[0][0] in _REPEATCODES: (6)
 if item[0][0] is SUBPATTERN: (6)
 if sourcematch("?"): (6)
 elif sourcematch("+"): (5)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (5)
 self.data[index] = code (8)
 break # end of subpattern (17)
 for i in range(len(subpattern))[::-1]: (49)
 op, av = subpattern[i] (31)
 if op is SUBPATTERN: (31)
 return subpattern (18)
 if not sourcematch("|"): (18)
 self.__next() (39)
 return True (39)
 if not nested: (6)
 char = sourceget() (10)
 if char is None: (10)
 if char == "P": (10)
 elif char == ":": (10)
 elif char == "#": (8)
 elif char in "=!<": (8)
 dir = 1 (8)
 if char == "<": (8)
 char = sourceget() (4)
 if char is None: (4)
 if char not in "=!": (4)
 dir = -1 # lookbehind (4)
 lookbehindgroups = state.lookbehindgroups (4)
 if lookbehindgroups is None: (4)
 state.lookbehindgroups = state.groups (4)
 p = _parse_sub(source, state, verbose, nested + 1) (8)
 return code (12)
 code1 = code1[1][0] (12)
 if set and this in '-&~|' and source.next == this: (12)
 code1 = LITERAL, _ord(this) (12)
 break (12)
 if len(items) == 1: (12)
 return items[0] (8)
 if dir < 0: (8)
 if lookbehindgroups is None: (4)
 state.lookbehindgroups = None (4)
 if not sourcematch(")"): (8)
 if char == "=": (8)
 subpatternappend((ASSERT, (dir, p))) (8)
 continue (8)
 subpatternappend((LITERAL, _ord(this))) (7)
 elif this == "{": (3)
 if source.next == "}": (3)
 min, max = 0, MAXREPEAT (3)
 lo = hi = "" (3)
 while source.next in DIGITS: (6)
 lo += sourceget() (3)
 if sourcematch(","): (3)
 while source.next in DIGITS: (2)
 if not sourcematch("}"): (3)
 if lo: (3)
 min = int(lo) (3)
 if min >= MAXREPEAT: (3)
 if hi: (3)
 code = _escape(source, this, state) (3)
 code = CATEGORIES.get(escape) (3)
 if code: (3)
 return code (3)
 subpatternappend(code) (3)
 set.insert(0, (NEGATE, None)) (6)
 subpattern[-1] = (MIN_REPEAT, (min, max, item)) (1)
 capture = False (2)
 group = None (2)
 hi = lo (1)
 max = int(hi) (1)
 if max >= MAXREPEAT: (1)
 if max < min: (1)
 subpattern = SubPattern(state) (4)
 while True: (4)
 prefix = None (4)
 for item in items: (8)
 if not item: (8)
 if prefix is None: (8)
 prefix = item[0] (4)
 elif item[0] != prefix: (4)
 break (4)
 break (4)
 set = [] (4)
 for item in items: (5)
 if len(item) != 1: (5)
 op, av = item[0] (4)
 if op is LITERAL: (4)
 elif op is IN and av[0][0] is not NEGATE: (4)
 break (3)
 subpattern.append((BRANCH, (None, items))) (4)
 return subpattern (4)
 if not source.match(")"): (3)
 if group is not None: (3)
 if atomic: (3)
 subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p))) (3)
 min, max = 0, 1 (1)
 group, add_flags, del_flags, p = av (3)
 if group is None and not add_flags and not del_flags: (3)
 subpattern[i: i+1] = p (2)
 set.extend(av) (1)
 break (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 state.closegroup(group, p) (1)
 self.groupwidths[gid] = p.getwidth() (1)
 if self.width is not None: (12)
 lo = hi = 0 (12)
 for op, av in self.data: (30)
 if op is BRANCH: (18)
 i = MAXWIDTH (3)
 j = 0 (3)
 for av in av[1]: (11)
 l, h = av.getwidth() (8)
 elif op is ATOMIC_GROUP: (15)
 elif op is SUBPATTERN: (15)
 elif op in _REPEATCODES: (15)
 i, j = av[2].getwidth() (3)
 elif op in _UNITCODES: (12)
 lo = lo + 1 (4)
 hi = hi + 1 (4)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (12)
 return self.width (12)
 lo = lo + i * av[0] (3)
 if av[1] == MAXREPEAT and j: (3)
 hi = MAXWIDTH (3)
 i = min(i, l) (8)
 j = max(j, h) (8)
 elif op is GROUPREF: (8)
 elif op is GROUPREF_EXISTS: (8)
 elif op is SUCCESS: (8)
 lo = lo + i (3)
 hi = hi + j (3)
 break # end of pattern (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (1)
 for op, av in self.data: (2)
 if op is BRANCH: (1)
 elif op is ATOMIC_GROUP: (1)
 elif op is SUBPATTERN: (1)
 i, j = av[-1].getwidth() (1)
 return self.width (1)
 lo = lo + i (1)
 hi = hi + j (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (1)
 return self.width (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (2)
 prefixappend = prefix.append (2)
 prefix_skip = None (2)
 iscased = _get_iscased(flags) (2)
 if not flags & SRE_FLAG_IGNORECASE: (3)
 return None (3)
 for op, av in pattern.data: (2)
 if op is LITERAL: (2)
 elif op is SUBPATTERN: (2)
 group, add_flags, del_flags, p = av (1)
 flags1 = _combine_flags(flags, add_flags, del_flags) (1)
 if add_flags & TYPE_FLAGS: (3)
 return (flags | add_flags) & ~del_flags (3)
 if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE: (1)
 prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1) (1)
 break (1)
 return prefix, prefix_skip, False (2)
 if prefix_skip is None: (1)
 if group is not None: (1)
 prefix_skip = len(prefix) (1)
 prefix.extend(prefix1) (1)
 if not got_all: (1)
 break (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (2)
 if not pattern.data: (2)
 op, av = pattern.data[0] (2)
 if op is not SUBPATTERN: (2)
 group, add_flags, del_flags, pattern = av (1)
 flags = _combine_flags(flags, add_flags, del_flags) (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 charset = [] (1)
 charsetappend = charset.append (1)
 for p in av[1]: (1)
 if not p: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is LITERAL and not (iscased and iscased(av)): (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (26)
 _len = len (26)
 LITERAL_CODES = _LITERAL_CODES (26)
 REPEATING_CODES = _REPEATING_CODES (26)
 SUCCESS_CODES = _SUCCESS_CODES (26)
 ASSERT_CODES = _ASSERT_CODES (26)
 iscased = None (26)
 tolower = None (26)
 fixes = None (26)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (26)
 for op, av in pattern: (65)
_parser.py (63) if isinstance(index, slice): (63)
 return self.data[index] (63)

 if op in LITERAL_CODES: (39)
 elif op is IN: (32)
 elif op is ANY: (20)
 elif op in REPEATING_CODES: (20)
 elif op is SUBPATTERN: (14)
 group, add_flags, del_flags, p = av (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2) (1)
 _compile(code, p, _combine_flags(flags, add_flags, del_flags)) (1)
 elif op is ATOMIC_GROUP: (13)
 elif op in SUCCESS_CODES: (13)
 elif op in ASSERT_CODES: (13)
 elif op is AT: (5)
 elif op is BRANCH: (4)
 emit(op) (4)
 tail = [] (4)
 tailappend = tail.append (4)
 for av in av[1]: (14)
 skip = _len(code); emit(0) (10)
 _compile(code, av, flags) (10)
 if _simple(av[2]): (6)
 if len(p) != 1: (6)
_parser.py (6) return len(self.data) (6)

 op, av = p[0] (6)
_parser.py (6) if isinstance(index, slice): (6)
 return self.data[index] (6)

 if op is SUBPATTERN: (6)
 return op in _UNIT_CODES (6)
 emit(REPEATING_CODES[op][2]) (6)
 skip = _len(code); emit(0) (6)
 emit(av[0]) (6)
 emit(av[1]) (6)
 _compile(code, av[2], flags) (6)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (12)
 out = [] (12)
 tail = [] (12)
 charmap = bytearray(256) (12)
 hascased = False (12)
 for op, av in charset: (64)
 while True: (52)
 try: (52)
 if op is LITERAL: (52)
 if fixup: # IGNORECASE and not LOCALE (32)
 charmap[av] = 1 (32)
 break (52)
 runs = [] (12)
 q = 0 (12)
 while True: (22)
 p = charmap.find(1, q) (22)
 if p < 0: (22)
 if len(runs) >= 2: (12)
 q = charmap.find(0, p) (10)
 if q < 0: (10)
 runs.append((p, q)) (10)
 break (10)
 if runs is not None: (12)
 for p, q in runs: (16)
 if q - p == 1: (6)
 out.append((RANGE, (p, q - 1))) (3)
 out.append((LITERAL, p)) (3)
 out += tail (10)
 if hascased or len(out) < len(charset): (10)
 return out, hascased (3)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (12)
 elif not hascased: (12)
 emit(IN) (12)
 skip = _len(code); emit(0) (12)
 _compile_charset(charset, flags, code) (12)
 emit = code.append (12)
 for op, av in charset: (40)
 emit(op) (28)
 if op is NEGATE: (28)
 elif op is LITERAL: (22)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (19)
 emit(av[0]) (3)
 emit(av[1]) (3)
 emit(av) (3)
 emit(FAILURE) (12)
 code[skip] = _len(code) - skip (12)
 emit(SUCCESS) (6)
 code[skip] = _len(code) - skip (6)
 emit(JUMP) (10)
 tailappend(_len(code)); emit(0) (10)
 code[skip] = _len(code) - skip (10)
 emit(op) (8)
 skip = _len(code); emit(0) (8)
 if av[0] >= 0: (8)
 lo, hi = av[1].getwidth() (4)
_parser.py (4) if self.width is not None: (5)
 lo = hi = 0 (5)
 for op, av in self.data: (14)
 if op is BRANCH: (9)
 elif op is ATOMIC_GROUP: (9)
 elif op is SUBPATTERN: (9)
 elif op in _REPEATCODES: (9)
 elif op in _UNITCODES: (8)
 lo = lo + 1 (8)
 hi = hi + 1 (8)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (5)
 return self.width (5)
 i, j = av[2].getwidth() (1)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = hi + j * av[1] (1)

 if lo > MAXCODE: (4)
 if lo != hi: (4)
 emit(lo) # look behind (4)
 _compile(code, av[1], flags) (8)
 elif op is RANGE: (20)
 elif op is NEGATE: (20)
 tail.append((op, av)) (14)
 runs = None (2)
 break (2)
 if len(charmap) == 256: (2)
 data = _mk_bitmap(charmap) (2)
 s = bits.translate(_BITS_TRANS)[::-1] (2)
 for i in range(len(s), 0, -_CODEBITS)] (20)
 return [_int(s[i - _CODEBITS: i], 2) (20)
 out.append((CHARSET, data)) (2)
 out += tail (2)
 return out, hascased (2)
 elif op is CHARSET: (16)
 code.extend(av) (2)
 elif op is BIGCHARSET: (14)
 elif op is CATEGORY: (14)
 if flags & SRE_FLAG_LOCALE: (14)
 elif flags & SRE_FLAG_UNICODE: (14)
 emit(CH_UNICODE[av]) (14)
 emit(SUCCESS) (8)
 code[skip] = _len(code) - skip (8)
 if not flags & SRE_FLAG_IGNORECASE: (7)
 emit(op) (7)
 emit(av) (7)
 emit(0) # look ahead (4)
 return charset, hascased (7)
 out.append((op, av)) (6)
 pass (6)
 emit(FAILURE) # end of branch (4)
 for tail in tail: (14)
 code[tail] = _len(code) - tail (10)
 emit(op) (1)
 if flags & SRE_FLAG_MULTILINE: (1)
 if flags & SRE_FLAG_LOCALE: (1)
 elif flags & SRE_FLAG_UNICODE: (1)
 av = AT_UNICODE.get(av, av) (1)
 emit(av) (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2+1) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 )''' % {'wp': word_punct, 'lt': letter, (2)
 'ws': whitespace, 'nws': nowhitespace}, (1)
 re.VERBOSE) (1)
 del word_punct, letter, nowhitespace (1)
 wordsep_simple_re = re.compile(r'(%s+)' % whitespace) (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (12)
 try: (12)
 char = self.decoded_string[index] (12)
 if char == "\\": (11)
 self.index = index + 1 (11)
 self.next = char (11)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (2)
 itemsappend = items.append (2)
 sourcematch = source.match (2)
 start = source.tell() (2)
 return self.index - len(self.next or '') (5)
 while True: (2)
 itemsappend(_parse(source, state, verbose, nested + 1, (4)
 not nested and not items)) (2)
 subpattern = SubPattern(state) (2)
 self.state = state (3)
 if data is None: (3)
 data = [] (2)
 self.data = data (3)
 self.width = None (3)
 subpatternappend = subpattern.append (2)
 sourceget = source.get (2)
 sourcematch = source.match (2)
 _len = len (2)
 _ord = ord (2)
 while True: (5)
 this = source.next (5)
 if this is None: (5)
 if this in "|)": (4)
 sourceget() (3)
 this = self.next (10)
 self.__next() (10)
 return this (10)
 if verbose: (3)
 if this[0] == "\\": (3)
 elif this not in SPECIAL_CHARS: (3)
 elif this == "[": (3)
 elif this in REPEAT_CHARS: (2)
 elif this == ".": (1)
 elif this == "(": (1)
 start = source.tell() - 1 (1)
 capture = True (1)
 atomic = False (1)
 name = None (1)
 add_flags = 0 (1)
 del_flags = 0 (1)
 if sourcematch("?"): (1)
 if char == self.next: (13)
 return False (12)
 if capture: (1)
 try: (1)
 group = state.opengroup(name) (1)
 gid = self.groups (1)
 return len(self.groupwidths) (2)
 self.groupwidths.append(None) (1)
 if self.groups > MAXGROUPS: (1)
 if name is not None: (1)
 return gid (1)
 sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and (1)
 p = _parse_sub(source, state, sub_verbose, nested + 1) (1)
 index += 1 (6)
 try: (6)
 char += self.decoded_string[index] (6)
 here = source.tell() - 1 (1)
 set = [] (1)
 setappend = set.append (1)
 if source.next == '[': (1)
 negate = sourcematch("^") (1)
 while True: (7)
 this = sourceget() (7)
 if this is None: (7)
 if this == "]" and set: (7)
 elif this[0] == "\\": (6)
 code1 = _class_escape(source, this) (6)
 code = ESCAPES.get(escape) (6)
 if code: (6)
 code = CATEGORIES.get(escape) (6)
 if code and code[0] is IN: (6)
 try: (6)
 c = escape[1:2] (6)
 if c == "x": (6)
 elif c == "u" and source.istext: (6)
 elif c == "U" and source.istext: (6)
 elif c == "N" and source.istext: (6)
 elif c in OCTDIGITS: (6)
 elif c in DIGITS: (6)
 if len(escape) == 2: (6)
 if c in ASCIILETTERS: (6)
 return LITERAL, ord(escape[1]) (6)
 if sourcematch("-"): (6)
 if code1[0] is IN: (6)
 setappend(code1) (6)
 break (1)
 set = _uniq(set) (1)
 return list(dict.fromkeys(items)) (1)
 if _len(set) == 1 and set[0][0] is LITERAL: (1)
 if negate: (1)
 subpatternappend((IN, set)) (1)
 self.data.append(code) (2)
 here = source.tell() (1)
 if this == "?": (1)
 elif this == "*": (1)
 elif this == "+": (1)
 min, max = 1, MAXREPEAT (1)
 if subpattern: (1)
 return len(self.data) (4)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (6)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (5)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (1)
 break # end of subpattern (1)
 for i in range(len(subpattern))[::-1]: (4)
 op, av = subpattern[i] (2)
 if op is SUBPATTERN: (2)
 return subpattern (2)
 if not sourcematch("|"): (2)
 break (2)
 if len(items) == 1: (2)
 return items[0] (2)
 if not source.match(")"): (1)
 self.__next() (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 return True (1)
 if group is not None: (1)
 state.closegroup(group, p) (1)
 self.groupwidths[gid] = p.getwidth() (1)
 if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (4)
 if op is BRANCH: (2)
 elif op is ATOMIC_GROUP: (2)
 elif op is SUBPATTERN: (2)
 elif op in _REPEATCODES: (2)
 i, j = av[2].getwidth() (1)
 elif op in _UNITCODES: (1)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = MAXWIDTH (1)
 if atomic: (1)
 subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p))) (1)
 break # end of pattern (1)
 group, add_flags, del_flags, p = av (1)
 if group is None and not add_flags and not del_flags: (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (1)
 for op, av in self.data: (2)
 if op is BRANCH: (1)
 elif op is ATOMIC_GROUP: (1)
 elif op is SUBPATTERN: (1)
 i, j = av[-1].getwidth() (1)
 return self.width (1)
 lo = lo + i (1)
 hi = hi + j (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (1)
 return self.width (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (2)
 prefixappend = prefix.append (2)
 prefix_skip = None (2)
 iscased = _get_iscased(flags) (2)
 if not flags & SRE_FLAG_IGNORECASE: (3)
 return None (3)
 for op, av in pattern.data: (2)
 if op is LITERAL: (2)
 elif op is SUBPATTERN: (2)
 group, add_flags, del_flags, p = av (1)
 flags1 = _combine_flags(flags, add_flags, del_flags) (1)
 if add_flags & TYPE_FLAGS: (3)
 return (flags | add_flags) & ~del_flags (3)
 if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE: (1)
 prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1) (1)
 break (1)
 return prefix, prefix_skip, False (2)
 if prefix_skip is None: (1)
 if group is not None: (1)
 prefix_skip = len(prefix) (1)
 prefix.extend(prefix1) (1)
 if not got_all: (1)
 break (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (2)
 if not pattern.data: (2)
 op, av = pattern.data[0] (2)
 if op is not SUBPATTERN: (2)
 group, add_flags, del_flags, pattern = av (1)
 flags = _combine_flags(flags, add_flags, del_flags) (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (3)
 _len = len (3)
 LITERAL_CODES = _LITERAL_CODES (3)
 REPEATING_CODES = _REPEATING_CODES (3)
 SUCCESS_CODES = _SUCCESS_CODES (3)
 ASSERT_CODES = _ASSERT_CODES (3)
 iscased = None (3)
 tolower = None (3)
 fixes = None (3)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (3)
 for op, av in pattern: (6)
_parser.py (4) if isinstance(index, slice): (4)
 return self.data[index] (4)

 if op in LITERAL_CODES: (3)
 elif op is IN: (3)
 elif op is ANY: (2)
 elif op in REPEATING_CODES: (2)
 elif op is SUBPATTERN: (1)
 group, add_flags, del_flags, p = av (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2) (1)
 _compile(code, p, _combine_flags(flags, add_flags, del_flags)) (1)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (1)
 out = [] (1)
 tail = [] (1)
 charmap = bytearray(256) (1)
 hascased = False (1)
 for op, av in charset: (7)
 while True: (6)
 try: (6)
 if op is LITERAL: (6)
 if fixup: # IGNORECASE and not LOCALE (6)
 charmap[av] = 1 (6)
 break (6)
 runs = [] (1)
 q = 0 (1)
 while True: (3)
 p = charmap.find(1, q) (3)
 if p < 0: (3)
 if len(runs) >= 2: (2)
 q = charmap.find(0, p) (2)
 if q < 0: (2)
 runs.append((p, q)) (2)
 break (1)
 if runs is not None: (1)
 for p, q in runs: (3)
 if q - p == 1: (2)
 out.append((RANGE, (p, q - 1))) (1)
 out.append((LITERAL, p)) (1)
 out += tail (1)
 if hascased or len(out) < len(charset): (1)
 return out, hascased (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 elif not hascased: (1)
 emit(IN) (1)
 skip = _len(code); emit(0) (1)
 _compile_charset(charset, flags, code) (1)
 emit = code.append (1)
 for op, av in charset: (3)
 emit(op) (2)
 if op is NEGATE: (2)
 elif op is LITERAL: (2)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 emit(av) (1)
 emit(FAILURE) (1)
 code[skip] = _len(code) - skip (1)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2+1) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 del whitespace (1)
 sentence_end_re = re.compile(r'[a-z]'             # lowercase letter (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (17)
 try: (17)
 char = self.decoded_string[index] (17)
 if char == "\\": (16)
 self.index = index + 1 (16)
 self.next = char (16)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (1)
 itemsappend = items.append (1)
 sourcematch = source.match (1)
 start = source.tell() (1)
 return self.index - len(self.next or '') (5)
 while True: (1)
 itemsappend(_parse(source, state, verbose, nested + 1, (2)
 not nested and not items)) (1)
 subpattern = SubPattern(state) (1)
 self.state = state (2)
 if data is None: (2)
 data = [] (1)
 self.data = data (2)
 self.width = None (2)
 subpatternappend = subpattern.append (1)
 sourceget = source.get (1)
 sourcematch = source.match (1)
 _len = len (1)
 _ord = ord (1)
 while True: (6)
 this = source.next (6)
 if this is None: (6)
 if this in "|)": (5)
 sourceget() (5)
 this = self.next (15)
 self.__next() (15)
 return this (15)
 if verbose: (5)
 if this[0] == "\\": (5)
 elif this not in SPECIAL_CHARS: (4)
 elif this == "[": (4)
 here = source.tell() - 1 (3)
 set = [] (3)
 setappend = set.append (3)
 if source.next == '[': (3)
 negate = sourcematch("^") (3)
 if char == self.next: (12)
 return False (11)
 while True: (9)
 this = sourceget() (9)
 if this is None: (9)
 if this == "]" and set: (9)
 elif this[0] == "\\": (6)
 if set and this in '-&~|' and source.next == this: (1)
 code1 = LITERAL, _ord(this) (1)
 if sourcematch("-"): (6)
 self.__next() (1)
 return True (1)
 that = sourceget() (1)
 if that is None: (1)
 if that == "]": (1)
 if that[0] == "\\": (1)
 if that == '-': (1)
 code2 = LITERAL, _ord(that) (1)
 if code1[0] != LITERAL or code2[0] != LITERAL: (1)
 lo = code1[1] (1)
 hi = code2[1] (1)
 if hi < lo: (1)
 setappend((RANGE, (lo, hi))) (1)
 break (3)
 set = _uniq(set) (3)
 return list(dict.fromkeys(items)) (3)
 if _len(set) == 1 and set[0][0] is LITERAL: (3)
 if negate: (3)
 subpatternappend((IN, set)) (3)
 self.data.append(code) (4)
 index += 1 (6)
 try: (6)
 char += self.decoded_string[index] (6)
 code1 = _class_escape(source, this) (5)
 code = ESCAPES.get(escape) (5)
 if code: (5)
 code = CATEGORIES.get(escape) (5)
 if code and code[0] is IN: (5)
 try: (5)
 c = escape[1:2] (5)
 if c == "x": (5)
 elif c == "u" and source.istext: (5)
 elif c == "U" and source.istext: (5)
 elif c == "N" and source.istext: (5)
 elif c in OCTDIGITS: (5)
 elif c in DIGITS: (5)
 if len(escape) == 2: (5)
 if c in ASCIILETTERS: (5)
 return LITERAL, ord(escape[1]) (5)
 if code1[0] is IN: (5)
 setappend(code1) (5)
 elif this in REPEAT_CHARS: (1)
 here = source.tell() (1)
 if this == "?": (1)
 min, max = 0, 1 (1)
 if subpattern: (1)
 return len(self.data) (3)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (8)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (7)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 code = _escape(source, this, state) (1)
 code = CATEGORIES.get(escape) (1)
 if code: (1)
 return code (1)
 subpatternappend(code) (1)
 break # end of pattern (1)
 for i in range(len(subpattern))[::-1]: (5)
 op, av = subpattern[i] (4)
 if op is SUBPATTERN: (4)
 return subpattern (1)
 if not sourcematch("|"): (1)
 break (1)
 if len(items) == 1: (1)
 return items[0] (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (7)
 if op is BRANCH: (5)
 elif op is ATOMIC_GROUP: (5)
 elif op is SUBPATTERN: (5)
 elif op in _REPEATCODES: (5)
 elif op in _UNITCODES: (4)
 lo = lo + 1 (3)
 hi = hi + 1 (3)
 i, j = av[2].getwidth() (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = hi + j * av[1] (1)
 elif op is GROUPREF: (1)
 elif op is GROUPREF_EXISTS: (1)
 elif op is SUCCESS: (1)

 if hi > MAXCODE: (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (1)
 prefixappend = prefix.append (1)
 prefix_skip = None (1)
 iscased = _get_iscased(flags) (1)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 return None (2)
 for op, av in pattern.data: (1)
 if op is LITERAL: (1)
 elif op is SUBPATTERN: (1)
 break (1)
 return prefix, prefix_skip, False (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (1)
 if not pattern.data: (1)
 op, av = pattern.data[0] (1)
 if op is not SUBPATTERN: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 charset = av (1)
 if iscased: (1)
 return charset (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 mask = mask | SRE_INFO_CHARSET (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 charset, hascased = _optimize_charset(charset) (1)
 out = [] (4)
 tail = [] (4)
 charmap = bytearray(256) (4)
 hascased = False (4)
 for op, av in charset: (11)
 while True: (7)
 try: (7)
 if op is LITERAL: (7)
 elif op is RANGE: (2)
 r = range(av[0], av[1]+1) (2)
 if fixup: # IGNORECASE and not LOCALE (2)
 for i in r: (54)
 charmap[i] = 1 (52)
 break (7)
 runs = [] (4)
 q = 0 (4)
 while True: (10)
 p = charmap.find(1, q) (10)
 if p < 0: (10)
 if len(runs) >= 2: (7)
 q = charmap.find(0, p) (6)
 if q < 0: (6)
 runs.append((p, q)) (6)
 break (3)
 if runs is not None: (4)
 for p, q in runs: (7)
 if q - p == 1: (4)
 out.append((RANGE, (p, q - 1))) (2)
 out += tail (3)
 if hascased or len(out) < len(charset): (3)
 return charset, hascased (3)
 assert not hascased (1)
 _compile_charset(charset, flags, code) (1)
 emit = code.append (4)
 for op, av in charset: (9)
 emit(op) (5)
 if op is NEGATE: (5)
 elif op is LITERAL: (5)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (3)
 emit(av[0]) (2)
 emit(av[1]) (2)
 emit(FAILURE) (4)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (2)
 _len = len (2)
 LITERAL_CODES = _LITERAL_CODES (2)
 REPEATING_CODES = _REPEATING_CODES (2)
 SUCCESS_CODES = _SUCCESS_CODES (2)
 ASSERT_CODES = _ASSERT_CODES (2)
 iscased = None (2)
 tolower = None (2)
 fixes = None (2)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (2)
 for op, av in pattern: (7)
_parser.py (2) if isinstance(index, slice): (2)
 return self.data[index] (2)

 if op in LITERAL_CODES: (5)
 elif op is IN: (5)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (3)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (3)
 elif not hascased: (3)
 emit(IN) (3)
 skip = _len(code); emit(0) (3)
 _compile_charset(charset, flags, code) (3)
 code[skip] = _len(code) - skip (3)
 if fixup: # IGNORECASE and not LOCALE (5)
 charmap[av] = 1 (5)
 runs = None (1)
 break (1)
 if len(charmap) == 256: (1)
 data = _mk_bitmap(charmap) (1)
 s = bits.translate(_BITS_TRANS)[::-1] (1)
 for i in range(len(s), 0, -_CODEBITS)] (10)
 return [_int(s[i - _CODEBITS: i], 2) (10)
 out.append((CHARSET, data)) (1)
 out += tail (1)
 return out, hascased (1)
 elif op is CHARSET: (1)
 code.extend(av) (1)
 elif op is ANY: (2)
 elif op in REPEATING_CODES: (2)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 out.append((LITERAL, p)) (2)
 emit(av) (2)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 elif op is SUBPATTERN: (1)
 elif op is ATOMIC_GROUP: (1)
 elif op in SUCCESS_CODES: (1)
 elif op in ASSERT_CODES: (1)
 elif op is AT: (1)
 emit(op) (1)
 if flags & SRE_FLAG_MULTILINE: (1)
 if flags & SRE_FLAG_LOCALE: (1)
 elif flags & SRE_FLAG_UNICODE: (1)
 av = AT_UNICODE.get(av, av) (1)
 emit(av) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 width=70, (1)
 initial_indent="", (1)
 subsequent_indent="", (1)
 expand_tabs=True, (1)
 replace_whitespace=True, (1)
 fix_sentence_endings=False, (1)
 break_long_words=True, (1)
 drop_whitespace=True, (1)
 break_on_hyphens=True, (1)
 tabsize=8, (1)
 def __init__(self, (2)
 max_lines=None, (1)
 placeholder=' [...]'): (1)
 def _munge_whitespace(self, text): (1)
 def _split(self, text): (1)
 def _fix_sentence_endings(self, chunks): (1)
 def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width): (1)
 def _wrap_chunks(self, chunks): (1)
 def _split_chunks(self, text): (1)
 def wrap(self, text): (1)
 def fill(self, text): (1)
 def wrap(text, width=70, **kwargs): (1)
 def fill(text, width=70, **kwargs): (1)
 def shorten(text, width, **kwargs): (1)
 _whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE) (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 flags = flags.value (1)
enum.py (1) if instance is None: (1)
 if self.fget is not None: (1)
 return self.fget(instance) (1)
 return self._value_ (1)

 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (8)
 try: (8)
 char = self.decoded_string[index] (8)
 if char == "\\": (7)
 self.index = index + 1 (7)
 self.next = char (7)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (1)
 itemsappend = items.append (1)
 sourcematch = source.match (1)
 start = source.tell() (1)
 return self.index - len(self.next or '') (3)
 while True: (1)
 itemsappend(_parse(source, state, verbose, nested + 1, (2)
 not nested and not items)) (1)
 subpattern = SubPattern(state) (1)
 self.state = state (2)
 if data is None: (2)
 data = [] (1)
 self.data = data (2)
 self.width = None (2)
 subpatternappend = subpattern.append (1)
 sourceget = source.get (1)
 sourcematch = source.match (1)
 _len = len (1)
 _ord = ord (1)
 while True: (5)
 this = source.next (5)
 if this is None: (5)
 if this in "|)": (4)
 sourceget() (4)
 this = self.next (7)
 self.__next() (7)
 return this (7)
 if verbose: (4)
 if this[0] == "\\": (4)
 elif this not in SPECIAL_CHARS: (4)
 elif this == "[": (4)
 elif this in REPEAT_CHARS: (3)
 elif this == ".": (2)
 elif this == "(": (2)
 elif this == "^": (2)
 subpatternappend((AT, AT_BEGINNING)) (1)
 self.data.append(code) (3)
 here = source.tell() - 1 (1)
 set = [] (1)
 setappend = set.append (1)
 if source.next == '[': (1)
 negate = sourcematch("^") (1)
 if char == self.next: (6)
 return False (6)
 while True: (3)
 this = sourceget() (3)
 if this is None: (3)
 if this == "]" and set: (3)
 elif this[0] == "\\": (2)
 if set and this in '-&~|' and source.next == this: (2)
 code1 = LITERAL, _ord(this) (2)
 if sourcematch("-"): (2)
 if code1[0] is IN: (2)
 setappend(code1) (2)
 break (1)
 set = _uniq(set) (1)
 return list(dict.fromkeys(items)) (1)
 if _len(set) == 1 and set[0][0] is LITERAL: (1)
 if negate: (1)
 subpatternappend((IN, set)) (1)
 here = source.tell() (1)
 if this == "?": (1)
 elif this == "*": (1)
 elif this == "+": (1)
 min, max = 1, MAXREPEAT (1)
 if subpattern: (1)
 return len(self.data) (3)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (7)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (6)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 elif this == "$": (1)
 subpatternappend((AT, AT_END)) (1)
 break # end of pattern (1)
 for i in range(len(subpattern))[::-1]: (4)
 op, av = subpattern[i] (3)
 if op is SUBPATTERN: (3)
 return subpattern (1)
 if not sourcematch("|"): (1)
 break (1)
 if len(items) == 1: (1)
 return items[0] (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (6)
 if op is BRANCH: (4)
 elif op is ATOMIC_GROUP: (4)
 elif op is SUBPATTERN: (4)
 elif op in _REPEATCODES: (4)
 elif op in _UNITCODES: (3)
 elif op is GROUPREF: (2)
 elif op is GROUPREF_EXISTS: (2)
 elif op is SUCCESS: (2)
 i, j = av[2].getwidth() (1)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = MAXWIDTH (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (1)
 prefixappend = prefix.append (1)
 prefix_skip = None (1)
 iscased = _get_iscased(flags) (1)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 return None (2)
 for op, av in pattern.data: (1)
 if op is LITERAL: (1)
 elif op is SUBPATTERN: (1)
 break (1)
 return prefix, prefix_skip, False (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (1)
 if not pattern.data: (1)
 op, av = pattern.data[0] (1)
 if op is not SUBPATTERN: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (2)
 _len = len (2)
 LITERAL_CODES = _LITERAL_CODES (2)
 REPEATING_CODES = _REPEATING_CODES (2)
 SUCCESS_CODES = _SUCCESS_CODES (2)
 ASSERT_CODES = _ASSERT_CODES (2)
 iscased = None (2)
 tolower = None (2)
 fixes = None (2)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (2)
 for op, av in pattern: (6)
_parser.py (2) if isinstance(index, slice): (2)
 return self.data[index] (2)

 if op in LITERAL_CODES: (4)
 elif op is IN: (4)
 elif op is ANY: (3)
 elif op in REPEATING_CODES: (3)
 elif op is SUBPATTERN: (2)
 elif op is ATOMIC_GROUP: (2)
 elif op in SUCCESS_CODES: (2)
 elif op in ASSERT_CODES: (2)
 elif op is AT: (2)
 emit(op) (2)
 if flags & SRE_FLAG_MULTILINE: (2)
 av = AT_MULTILINE.get(av, av) (2)
 if flags & SRE_FLAG_LOCALE: (2)
 elif flags & SRE_FLAG_UNICODE: (2)
 av = AT_UNICODE.get(av, av) (2)
 emit(av) (2)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (1)
 out = [] (1)
 tail = [] (1)
 charmap = bytearray(256) (1)
 hascased = False (1)
 for op, av in charset: (3)
 while True: (2)
 try: (2)
 if op is LITERAL: (2)
 if fixup: # IGNORECASE and not LOCALE (2)
 charmap[av] = 1 (2)
 break (2)
 runs = [] (1)
 q = 0 (1)
 while True: (3)
 p = charmap.find(1, q) (3)
 if p < 0: (3)
 if len(runs) >= 2: (2)
 q = charmap.find(0, p) (2)
 if q < 0: (2)
 runs.append((p, q)) (2)
 break (1)
 if runs is not None: (1)
 for p, q in runs: (3)
 if q - p == 1: (2)
 out.append((LITERAL, p)) (2)
 out += tail (1)
 if hascased or len(out) < len(charset): (1)
 return charset, hascased (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 elif not hascased: (1)
 emit(IN) (1)
 skip = _len(code); emit(0) (1)
 _compile_charset(charset, flags, code) (1)
 emit = code.append (1)
 for op, av in charset: (3)
 emit(op) (2)
 if op is NEGATE: (2)
 elif op is LITERAL: (2)
 emit(av) (2)
 emit(FAILURE) (1)
 code[skip] = _len(code) - skip (1)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 _leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE) (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 flags = flags.value (1)
enum.py (1) if instance is None: (1)
 if self.fget is not None: (1)
 return self.fget(instance) (1)
 return self._value_ (1)

 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (19)
 try: (19)
 char = self.decoded_string[index] (19)
 if char == "\\": (18)
 self.index = index + 1 (18)
 self.next = char (18)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (3)
 itemsappend = items.append (3)
 sourcematch = source.match (3)
 start = source.tell() (3)
 return self.index - len(self.next or '') (8)
 while True: (3)
 itemsappend(_parse(source, state, verbose, nested + 1, (6)
 not nested and not items)) (3)
 subpattern = SubPattern(state) (3)
 self.state = state (4)
 if data is None: (4)
 data = [] (3)
 self.data = data (4)
 self.width = None (4)
 subpatternappend = subpattern.append (3)
 sourceget = source.get (3)
 sourcematch = source.match (3)
 _len = len (3)
 _ord = ord (3)
 while True: (9)
 this = source.next (9)
 if this is None: (9)
 if this in "|)": (8)
 sourceget() (6)
 this = self.next (14)
 self.__next() (14)
 return this (14)
 if verbose: (6)
 if this[0] == "\\": (6)
 elif this not in SPECIAL_CHARS: (6)
 elif this == "[": (6)
 elif this in REPEAT_CHARS: (4)
 elif this == ".": (3)
 elif this == "(": (3)
 start = source.tell() - 1 (2)
 capture = True (2)
 atomic = False (2)
 name = None (2)
 add_flags = 0 (2)
 del_flags = 0 (2)
 if sourcematch("?"): (2)
 if char == self.next: (16)
 return False (12)
 if capture: (2)
 try: (1)
 group = state.opengroup(name) (1)
 gid = self.groups (1)
 return len(self.groupwidths) (2)
 self.groupwidths.append(None) (1)
 if self.groups > MAXGROUPS: (1)
 if name is not None: (1)
 return gid (1)
 sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and (2)
 p = _parse_sub(source, state, sub_verbose, nested + 1) (2)
 elif this == "^": (1)
 subpatternappend((AT, AT_BEGINNING)) (1)
 self.data.append(code) (5)
 here = source.tell() - 1 (2)
 set = [] (2)
 setappend = set.append (2)
 if source.next == '[': (2)
 negate = sourcematch("^") (2)
 while True: (7)
 this = sourceget() (7)
 if this is None: (7)
 if this == "]" and set: (7)
 elif this[0] == "\\": (5)
 if set and this in '-&~|' and source.next == this: (5)
 code1 = LITERAL, _ord(this) (5)
 if sourcematch("-"): (5)
 if code1[0] is IN: (5)
 setappend(code1) (5)
 break (2)
 set = _uniq(set) (2)
 return list(dict.fromkeys(items)) (2)
 if _len(set) == 1 and set[0][0] is LITERAL: (2)
 if negate: (2)
 subpatternappend((IN, set)) (2)
 here = source.tell() (1)
 if this == "?": (1)
 elif this == "*": (1)
 min, max = 0, MAXREPEAT (1)
 if subpattern: (1)
 return len(self.data) (6)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (11)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (10)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (2)
 break # end of subpattern (2)
 for i in range(len(subpattern))[::-1]: (8)
 op, av = subpattern[i] (5)
 if op is SUBPATTERN: (5)
 return subpattern (3)
 if not sourcematch("|"): (3)
 break (3)
 if len(items) == 1: (3)
 return items[0] (3)
 if not source.match(")"): (2)
 self.__next() (4)
 return True (4)
 if group is not None: (2)
 state.closegroup(group, p) (1)
 self.groupwidths[gid] = p.getwidth() (1)
 if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (5)
 if op is BRANCH: (3)
 elif op is ATOMIC_GROUP: (3)
 elif op is SUBPATTERN: (3)
 elif op in _REPEATCODES: (3)
 elif op in _UNITCODES: (2)
 elif op is GROUPREF: (1)
 elif op is GROUPREF_EXISTS: (1)
 elif op is SUCCESS: (1)
 i, j = av[2].getwidth() (1)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = MAXWIDTH (1)
 if atomic: (2)
 subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p))) (2)
 char = sourceget() (1)
 if char is None: (1)
 if char == "P": (1)
 elif char == ":": (1)
 capture = False (1)
 group = None (1)
 set.insert(0, (NEGATE, None)) (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 break # end of pattern (1)
 group, add_flags, del_flags, p = av (2)
 if group is None and not add_flags and not del_flags: (2)
 subpattern[i: i+1] = p (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (1)
 for op, av in self.data: (3)
 if op is BRANCH: (2)
 elif op is ATOMIC_GROUP: (2)
 elif op is SUBPATTERN: (2)
 i, j = av[-1].getwidth() (1)
 return self.width (1)
 lo = lo + i (1)
 hi = hi + j (1)
 elif op in _REPEATCODES: (1)
 elif op in _UNITCODES: (1)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (1)
 return self.width (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (2)
 prefixappend = prefix.append (2)
 prefix_skip = None (2)
 iscased = _get_iscased(flags) (2)
 if not flags & SRE_FLAG_IGNORECASE: (3)
 return None (3)
 for op, av in pattern.data: (2)
 if op is LITERAL: (2)
 elif op is SUBPATTERN: (2)
 group, add_flags, del_flags, p = av (1)
 flags1 = _combine_flags(flags, add_flags, del_flags) (1)
 if add_flags & TYPE_FLAGS: (3)
 return (flags | add_flags) & ~del_flags (3)
 if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE: (1)
 prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1) (1)
 break (1)
 return prefix, prefix_skip, False (2)
 if prefix_skip is None: (1)
 if group is not None: (1)
 prefix_skip = len(prefix) (1)
 prefix.extend(prefix1) (1)
 if not got_all: (1)
 break (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (2)
 if not pattern.data: (2)
 op, av = pattern.data[0] (2)
 if op is not SUBPATTERN: (2)
 group, add_flags, del_flags, pattern = av (1)
 flags = _combine_flags(flags, add_flags, del_flags) (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (3)
 _len = len (3)
 LITERAL_CODES = _LITERAL_CODES (3)
 REPEATING_CODES = _REPEATING_CODES (3)
 SUCCESS_CODES = _SUCCESS_CODES (3)
 ASSERT_CODES = _ASSERT_CODES (3)
 iscased = None (3)
 tolower = None (3)
 fixes = None (3)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (3)
 for op, av in pattern: (8)
_parser.py (5) if isinstance(index, slice): (5)
 return self.data[index] (5)

 if op in LITERAL_CODES: (5)
 elif op is IN: (5)
 elif op is ANY: (3)
 elif op in REPEATING_CODES: (3)
 elif op is SUBPATTERN: (2)
 group, add_flags, del_flags, p = av (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2) (1)
 _compile(code, p, _combine_flags(flags, add_flags, del_flags)) (1)
 elif op is ATOMIC_GROUP: (1)
 elif op in SUCCESS_CODES: (1)
 elif op in ASSERT_CODES: (1)
 elif op is AT: (1)
 emit(op) (1)
 if flags & SRE_FLAG_MULTILINE: (1)
 av = AT_MULTILINE.get(av, av) (1)
 if flags & SRE_FLAG_LOCALE: (1)
 elif flags & SRE_FLAG_UNICODE: (1)
 av = AT_UNICODE.get(av, av) (1)
 emit(av) (1)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (2)
 out = [] (2)
 tail = [] (2)
 charmap = bytearray(256) (2)
 hascased = False (2)
 for op, av in charset: (8)
 while True: (6)
 try: (6)
 if op is LITERAL: (6)
 if fixup: # IGNORECASE and not LOCALE (5)
 charmap[av] = 1 (5)
 break (6)
 runs = [] (2)
 q = 0 (2)
 while True: (6)
 p = charmap.find(1, q) (6)
 if p < 0: (6)
 if len(runs) >= 2: (4)
 q = charmap.find(0, p) (4)
 if q < 0: (4)
 runs.append((p, q)) (4)
 break (2)
 if runs is not None: (2)
 for p, q in runs: (6)
 if q - p == 1: (4)
 out.append((LITERAL, p)) (3)
 out += tail (2)
 if hascased or len(out) < len(charset): (2)
 return charset, hascased (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (2)
 elif not hascased: (2)
 emit(IN) (2)
 skip = _len(code); emit(0) (2)
 _compile_charset(charset, flags, code) (2)
 emit = code.append (2)
 for op, av in charset: (7)
 emit(op) (5)
 if op is NEGATE: (5)
 elif op is LITERAL: (4)
 emit(av) (3)
 emit(FAILURE) (2)
 code[skip] = _len(code) - skip (2)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2+1) (1)
 elif op is RANGE: (1)
 elif op is NEGATE: (1)
 out.append((op, av)) (1)
 out.append((RANGE, (p, q - 1))) (1)
 return out, hascased (1)
 pass (1)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 def dedent(text): (1)
 def indent(text, prefix, predicate=None): (1)
 if __name__ == "__main__": (1)

platform.py (1) """ This module tries to retrieve as much platform-identifying data as (1)
 __copyright__ = """ (1)
 __version__ = '1.0.8' (1)
 import collections (1)
 import os (1)
 import re (1)
 import sys (1)
 import functools (1)
 import itertools (1)
 try: (1)
 import _wmi (1)

_datasource.py (1) """A file interface for handling local and remote data files. (1)
 import os (1)
 from .._utils import set_module (1)

_iotools.py (1) """A collection of functions designed to help I/O with ascii files. (1)
 __docformat__ = "restructuredtext en" (1)
 import numpy as np (1)

scimath.py (1) from ._scimath_impl import ( (1)

_scimath_impl.py (1) """ (1)
 import numpy._core.numeric as nx (1)

_type_check_impl.py (1) """Automatically adapted for numpy Sep 19, 2005 by convertcode.py (1)
 import functools (1)
 __all__ = ['iscomplexobj', 'isrealobj', 'imag', 'iscomplex', (1)
 from .._utils import set_module (1)

_ufunclike_impl.py (1) """ (1)
 __all__ = ['fix', 'isneginf', 'isposinf'] (1)
 import numpy._core.numeric as nx (1)

stride_tricks.py (1) from ._stride_tricks_impl import ( (1)

_stride_tricks_impl.py (1) """ (1)
 import numpy as np (1)

_index_tricks_impl.py (1) import functools (1)
 import sys (1)
 import math (1)
 import warnings (1)
 import numpy as np (1)

defmatrix.py (1) __all__ = ['matrix', 'bmat', 'asmatrix'] (1)
 import sys (1)
 import warnings (1)
 import ast (1)
 from .._utils import set_module (1)

linalg.py (1) def __getattr__(attr_name): (1)

_linalg.py (1) """Lite version of scipy.linalg. (1)
 __all__ = ['matrix_power', 'solve', 'tensorsolve', 'tensorinv', 'inv', (1)
 import functools (1)
 import operator (1)
 import warnings (1)
 from typing import NamedTuple, Any (1)

typing.py (1) """ (1)
 from abc import abstractmethod, ABCMeta (1)
 import collections (1)
 from collections import defaultdict (1)

_twodim_base_impl.py (1) """ Basic functions for manipulating 2d arrays (1)
 import functools (1)
 import operator (1)
 from numpy._core._multiarray_umath import _array_converter (1)
 from numpy._core.numeric import ( (1)
 from numpy._core.overrides import finalize_array_function_like, set_module (1)
 from numpy._core import overrides (1)

__future__.py (1) """Record of phased-in incompatible language changes. (1)
 all_feature_names = [ (1)
 __all__ = ["all_feature_names"] + all_feature_names (1)
 CO_NESTED = 0x0010                      # nested_scopes (1)
 CO_GENERATOR_ALLOWED = 0                # generators (obsolete, was 0x1000) (1)
 CO_FUTURE_DIVISION = 0x20000            # division (1)
 CO_FUTURE_ABSOLUTE_IMPORT = 0x40000     # perform absolute imports by default (1)
 CO_FUTURE_WITH_STATEMENT = 0x80000      # with statement (1)
 CO_FUTURE_PRINT_FUNCTION = 0x100000     # print function (1)
 CO_FUTURE_UNICODE_LITERALS = 0x200000   # unicode string literals (1)
 CO_FUTURE_BARRY_AS_BDFL = 0x400000 (1)
 CO_FUTURE_GENERATOR_STOP = 0x800000     # StopIteration becomes RuntimeError in generators (1)
 CO_FUTURE_ANNOTATIONS = 0x1000000       # annotations become strings at runtime (1)
 class _Feature: (2)
 def __init__(self, optionalRelease, mandatoryRelease, compiler_flag): (1)
 def getOptionalRelease(self): (1)
 def getMandatoryRelease(self): (1)
 def __repr__(self): (1)
 nested_scopes = _Feature((2, 1, 0, "beta",  1), (2)
 (2, 2, 0, "alpha", 0), (1)
 CO_NESTED) (1)
 self.optional = optionalRelease (10)
 self.mandatory = mandatoryRelease (10)
 self.compiler_flag = compiler_flag (10)
 generators = _Feature((2, 2, 0, "alpha", 1), (2)
 (2, 3, 0, "final", 0), (1)
 CO_GENERATOR_ALLOWED) (1)
 division = _Feature((2, 2, 0, "alpha", 2), (2)
 (3, 0, 0, "alpha", 0), (1)
 CO_FUTURE_DIVISION) (1)
 absolute_import = _Feature((2, 5, 0, "alpha", 1), (2)
 (3, 0, 0, "alpha", 0), (1)
 CO_FUTURE_ABSOLUTE_IMPORT) (1)
 with_statement = _Feature((2, 5, 0, "alpha", 1), (2)
 (2, 6, 0, "alpha", 0), (1)
 CO_FUTURE_WITH_STATEMENT) (1)
 print_function = _Feature((2, 6, 0, "alpha", 2), (2)
 (3, 0, 0, "alpha", 0), (1)
 CO_FUTURE_PRINT_FUNCTION) (1)
 unicode_literals = _Feature((2, 6, 0, "alpha", 2), (2)
 (3, 0, 0, "alpha", 0), (1)
 CO_FUTURE_UNICODE_LITERALS) (1)
 barry_as_FLUFL = _Feature((3, 1, 0, "alpha", 2), (2)
 (4, 0, 0, "alpha", 0), (1)
 CO_FUTURE_BARRY_AS_BDFL) (1)
 generator_stop = _Feature((3, 5, 0, "beta", 1), (2)
 (3, 7, 0, "alpha", 0), (1)
 CO_FUTURE_GENERATOR_STOP) (1)
 annotations = _Feature((3, 7, 0, "beta", 1), (2)
 None, (1)
 CO_FUTURE_ANNOTATIONS) (1)

_nested_sequence.py (1) """A module containing the `_NestedSequence` protocol.""" (1)
 from __future__ import annotations (1)
 from typing import ( (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 if TYPE_CHECKING: (1)
 __all__ = ["_NestedSequence"] (1)
 _T_co = TypeVar("_T_co", covariant=True) (1)
 @runtime_checkable (3)
typing.py (1) if not issubclass(cls, Generic) or not getattr(cls, '_is_protocol', False): (1)
 cls._is_runtime_protocol = True (1)
 cls.__non_callable_proto_members__ = set() (1)
 for attr in cls.__protocol_attrs__: (8)
 try: (7)
 is_callable = callable(getattr(cls, attr, None)) (7)
 if not is_callable: (7)
 return cls (1)

 class _NestedSequence(Protocol[_T_co]): (2)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 if not args: (1)
 if not all(_is_typevar_like(p) for p in args): (3)
 return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x) (1)
 if len(set(args)) != len(args): (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if t not in parameters: (1)
 if enforce_default_ordering: (1)
 if type_var_tuple_encountered and t.has_default(): (1)
 if t.has_default(): (1)
 elif default_encountered: (1)
 parameters.append(t) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)
 if isinstance(self.__origin__, _SpecialForm): (1)
 if self._name:  # generic version of an ABC or built-in class (1)
 if self.__origin__ is Generic: (1)
 return (self.__origin__,) (1)

 """A protocol for representing nested sequences. (1)
 def __len__(self, /) -> int: (1)
 def __getitem__(self, index: int, /) -> _T_co | _NestedSequence[_T_co]: (1)
 def __contains__(self, x: object, /) -> bool: (1)
 def __iter__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: (1)
 def __reversed__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: (1)
 def count(self, value: Any, /) -> int: (1)
 def index(self, value: Any, /) -> int: (1)
typing.py (1) if name == "Protocol" and bases == (Generic,): (1)
 elif Protocol in bases: (1)
 for base in bases: (2)
 base in {object, Generic} (1)
 or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) (1)
 issubclass(base, Generic) (1)
 and getattr(base, "_is_protocol", False) (1)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (1)
<frozen abc> (1) (1)

 super().__init_subclass__(*args, **kwargs) (1)
 super(Generic, cls).__init_subclass__(*args, **kwargs) (1)
 tvars = [] (1)
 if '__orig_bases__' in cls.__dict__: (1)
 error = Generic in cls.__orig_bases__ (1)
 if not isinstance(other, _GenericAlias): (1)
 return NotImplemented (1)
 if error: (1)
 if '__orig_bases__' in cls.__dict__: (1)
 tvars = _collect_type_parameters(cls.__orig_bases__) (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 return attr.startswith('__') and attr.endswith('__') (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 gvars = None (1)
 for base in cls.__orig_bases__: (2)
 if (isinstance(base, _GenericAlias) and (1)
 base.__origin__ is Generic): (1)
 if gvars is not None: (1)
 cls.__parameters__ = tuple(tvars) (1)
 if not cls.__dict__.get('_is_protocol', False): (1)
 cls._is_protocol = any(b is Protocol for b in cls.__bases__) (2)
 if '__subclasshook__' not in cls.__dict__: (1)
 cls.__subclasshook__ = _proto_hook (1)
 if cls._is_protocol and cls.__init__ is Protocol.__init__: (1)
 cls.__init__ = _no_init_or_replace_init (1)
<frozen abc> (1) (1)
 (1)

 super().__init__(*args, **kwargs) (1)
 if getattr(cls, "_is_protocol", False): (1)
 cls.__protocol_attrs__ = _get_protocol_attrs(cls) (1)
 attrs = set() (1)
 for base in cls.__mro__[:-1]:  # without object (4)
 if base.__name__ in {'Protocol', 'Generic'}: (3)
 annotations = getattr(base, '__annotations__', {}) (1)
 for attr in (*base.__dict__, *annotations): (22)
 if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: (21)
 attrs.add(attr) (7)
 continue (2)
 return attrs (1)


_nbit_base.py (1) """A module with the precisions of generic `~numpy.number` types.""" (1)
 from .._utils import set_module (1)

_nbit.py (1) """A module with the precisions of platform-specific `~numpy.number`s.""" (1)
 from typing import TypeAlias (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 from ._nbit_base import _8Bit, _16Bit, _32Bit, _64Bit, _96Bit, _128Bit (1)

_char_codes.py (1) from typing import Literal (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 _BoolCodes = Literal["bool", "bool_", "?", "|?", "=?", "<?", ">?"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UInt8Codes = Literal["uint8", "u1", "|u1", "=u1", "<u1", ">u1"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UInt16Codes = Literal["uint16", "u2", "|u2", "=u2", "<u2", ">u2"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UInt32Codes = Literal["uint32", "u4", "|u4", "=u4", "<u4", ">u4"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UInt64Codes = Literal["uint64", "u8", "|u8", "=u8", "<u8", ">u8"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Int8Codes = Literal["int8", "i1", "|i1", "=i1", "<i1", ">i1"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Int16Codes = Literal["int16", "i2", "|i2", "=i2", "<i2", ">i2"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Int32Codes = Literal["int32", "i4", "|i4", "=i4", "<i4", ">i4"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Int64Codes = Literal["int64", "i8", "|i8", "=i8", "<i8", ">i8"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Float16Codes = Literal["float16", "f2", "|f2", "=f2", "<f2", ">f2"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Float32Codes = Literal["float32", "f4", "|f4", "=f4", "<f4", ">f4"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Float64Codes = Literal["float64", "f8", "|f8", "=f8", "<f8", ">f8"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Complex64Codes = Literal["complex64", "c8", "|c8", "=c8", "<c8", ">c8"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Complex128Codes = Literal["complex128", "c16", "|c16", "=c16", "<c16", ">c16"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ByteCodes = Literal["byte", "b", "|b", "=b", "<b", ">b"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ShortCodes = Literal["short", "h", "|h", "=h", "<h", ">h"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _IntCCodes = Literal["intc", "i", "|i", "=i", "<i", ">i"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _IntPCodes = Literal["intp", "int", "int_", "n", "|n", "=n", "<n", ">n"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (9)
 if isinstance(p, _LiteralGenericAlias): (8)
 params.append(p) (8)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (10)
 return ((p, type(p)) for p in parameters) (10)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (19)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (9)
 if isinstance(t, type): (8)
 elif isinstance(t, tuple): (8)
 elif hasattr(t, '__typing_subst__'): (8)
 if _is_unpacked_typevartuple(t): (8)
 return ((not isinstance(x, type)) and (16)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (8)
 for x in getattr(t, '__parameters__', ()): (8)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _LongCodes = Literal["long", "l", "|l", "=l", "<l", ">l"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _IntCodes = _IntPCodes (1)
 _LongLongCodes = Literal["longlong", "q", "|q", "=q", "<q", ">q"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UByteCodes = Literal["ubyte", "B", "|B", "=B", "<B", ">B"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UShortCodes = Literal["ushort", "H", "|H", "=H", "<H", ">H"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UIntCCodes = Literal["uintc", "I", "|I", "=I", "<I", ">I"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UIntPCodes = Literal["uintp", "uint", "N", "|N", "=N", "<N", ">N"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ULongCodes = Literal["ulong", "L", "|L", "=L", "<L", ">L"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UIntCodes = _UIntPCodes (1)
 _ULongLongCodes = Literal["ulonglong", "Q", "|Q", "=Q", "<Q", ">Q"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _HalfCodes = Literal["half", "e", "|e", "=e", "<e", ">e"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _SingleCodes = Literal["single", "f", "|f", "=f", "<f", ">f"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _DoubleCodes = Literal["double", "float", "d", "|d", "=d", "<d", ">d"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _LongDoubleCodes = Literal["longdouble", "g", "|g", "=g", "<g", ">g"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _CSingleCodes = Literal["csingle", "F", "|F", "=F", "<F", ">F"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _CDoubleCodes = Literal["cdouble", "complex", "D", "|D", "=D", "<D", ">D"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _CLongDoubleCodes = Literal["clongdouble", "G", "|G", "=G", "<G", ">G"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _StrCodes = Literal["str", "str_", "unicode", "U", "|U", "=U", "<U", ">U"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (9)
 if isinstance(p, _LiteralGenericAlias): (8)
 params.append(p) (8)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (10)
 return ((p, type(p)) for p in parameters) (10)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (19)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (9)
 if isinstance(t, type): (8)
 elif isinstance(t, tuple): (8)
 elif hasattr(t, '__typing_subst__'): (8)
 if _is_unpacked_typevartuple(t): (8)
 return ((not isinstance(x, type)) and (16)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (8)
 for x in getattr(t, '__parameters__', ()): (8)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _BytesCodes = Literal["bytes", "bytes_", "S", "|S", "=S", "<S", ">S"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _VoidCodes = Literal["void", "V", "|V", "=V", "<V", ">V"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.append(p) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (8)
 return ((p, type(p)) for p in parameters) (8)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (15)
 a for a in args) (14)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (7)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 return ((not isinstance(x, type)) and (12)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ObjectCodes = Literal["object", "object_", "O", "|O", "=O", "<O", ">O"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (8)
 if isinstance(p, _LiteralGenericAlias): (7)
 params.append(p) (7)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (9)
 return ((p, type(p)) for p in parameters) (9)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (17)
 a for a in args) (16)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (8)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _DT64Codes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (146)
 if isinstance(p, _LiteralGenericAlias): (145)
 params.append(p) (145)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (147)
 return ((p, type(p)) for p in parameters) (147)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (293)
 a for a in args) (292)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (146)
 if isinstance(t, type): (145)
 elif isinstance(t, tuple): (145)
 elif hasattr(t, '__typing_subst__'): (145)
 if _is_unpacked_typevartuple(t): (145)
 return ((not isinstance(x, type)) and (290)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (145)
 for x in getattr(t, '__parameters__', ()): (145)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 "datetime64", "|datetime64", "=datetime64", (1)
 _TD64Codes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (146)
 if isinstance(p, _LiteralGenericAlias): (145)
 params.append(p) (145)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (147)
 return ((p, type(p)) for p in parameters) (147)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (293)
 a for a in args) (292)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (146)
 if isinstance(t, type): (145)
 elif isinstance(t, tuple): (145)
 elif hasattr(t, '__typing_subst__'): (145)
 if _is_unpacked_typevartuple(t): (145)
 return ((not isinstance(x, type)) and (290)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (145)
 for x in getattr(t, '__parameters__', ()): (145)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 "timedelta64", "|timedelta64", "=timedelta64", (1)
 _StringCodes = Literal["T", "|T", "=T", "<T", ">T"] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (6)
 if isinstance(p, _LiteralGenericAlias): (5)
 params.append(p) (5)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (7)
 return ((p, type(p)) for p in parameters) (7)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (13)
 a for a in args) (12)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (6)
 if isinstance(t, type): (5)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 return ((not isinstance(x, type)) and (10)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UnsignedIntegerCodes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (10)
 return ((p, type(p)) for p in parameters) (144)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (11)
 if isinstance(p, _LiteralGenericAlias): (10)
 params.extend(p.__args__) (10)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (63)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (125)
 a for a in args) (124)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (62)
 if isinstance(t, type): (61)
 elif isinstance(t, tuple): (61)
 elif hasattr(t, '__typing_subst__'): (61)
 if _is_unpacked_typevartuple(t): (61)
 return ((not isinstance(x, type)) and (122)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (61)
 for x in getattr(t, '__parameters__', ()): (61)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _UInt8Codes, (2)
 _UInt16Codes, (1)
 _UInt32Codes, (1)
 _UInt64Codes, (1)
 _UIntCodes, (1)
 _UByteCodes, (1)
 _UShortCodes, (1)
 _UIntCCodes, (1)
 _ULongCodes, (1)
 _ULongLongCodes, (1)
 _SignedIntegerCodes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (10)
 return ((p, type(p)) for p in parameters) (146)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (11)
 if isinstance(p, _LiteralGenericAlias): (10)
 params.extend(p.__args__) (10)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (64)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (127)
 a for a in args) (126)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (63)
 if isinstance(t, type): (62)
 elif isinstance(t, tuple): (62)
 elif hasattr(t, '__typing_subst__'): (62)
 if _is_unpacked_typevartuple(t): (62)
 return ((not isinstance(x, type)) and (124)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (62)
 for x in getattr(t, '__parameters__', ()): (62)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Int8Codes, (2)
 _Int16Codes, (1)
 _Int32Codes, (1)
 _Int64Codes, (1)
 _IntCodes, (1)
 _ByteCodes, (1)
 _ShortCodes, (1)
 _IntCCodes, (1)
 _LongCodes, (1)
 _LongLongCodes, (1)
 _FloatingCodes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (8)
 return ((p, type(p)) for p in parameters) (116)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (9)
 if isinstance(p, _LiteralGenericAlias): (8)
 params.extend(p.__args__) (8)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (45)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (89)
 a for a in args) (88)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (44)
 if isinstance(t, type): (43)
 elif isinstance(t, tuple): (43)
 elif hasattr(t, '__typing_subst__'): (43)
 if _is_unpacked_typevartuple(t): (43)
 return ((not isinstance(x, type)) and (86)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (43)
 for x in getattr(t, '__parameters__', ()): (43)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Float16Codes, (2)
 _Float32Codes, (1)
 _Float64Codes, (1)
 _LongDoubleCodes, (1)
 _HalfCodes, (1)
 _SingleCodes, (1)
 _DoubleCodes, (1)
 _LongDoubleCodes (1)
 _ComplexFloatingCodes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (5)
 return ((p, type(p)) for p in parameters) (74)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (6)
 if isinstance(p, _LiteralGenericAlias): (5)
 params.extend(p.__args__) (5)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (33)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (65)
 a for a in args) (64)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (32)
 if isinstance(t, type): (31)
 elif isinstance(t, tuple): (31)
 elif hasattr(t, '__typing_subst__'): (31)
 if _is_unpacked_typevartuple(t): (31)
 return ((not isinstance(x, type)) and (62)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (31)
 for x in getattr(t, '__parameters__', ()): (31)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _Complex64Codes, (2)
 _Complex128Codes, (1)
 _CSingleCodes, (1)
 _CDoubleCodes, (1)
 _CLongDoubleCodes, (1)
 _IntegerCodes = Literal[_UnsignedIntegerCodes, _SignedIntegerCodes] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (252)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, _LiteralGenericAlias): (2)
 params.extend(p.__args__) (2)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (125)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (249)
 a for a in args) (248)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (124)
 if isinstance(t, type): (123)
 elif isinstance(t, tuple): (123)
 elif hasattr(t, '__typing_subst__'): (123)
 if _is_unpacked_typevartuple(t): (123)
 return ((not isinstance(x, type)) and (246)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (123)
 for x in getattr(t, '__parameters__', ()): (123)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _InexactCodes = Literal[_FloatingCodes, _ComplexFloatingCodes] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (154)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, _LiteralGenericAlias): (2)
 params.extend(p.__args__) (2)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (76)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (151)
 a for a in args) (150)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (75)
 if isinstance(t, type): (74)
 elif isinstance(t, tuple): (74)
 elif hasattr(t, '__typing_subst__'): (74)
 if _is_unpacked_typevartuple(t): (74)
 return ((not isinstance(x, type)) and (148)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (74)
 for x in getattr(t, '__parameters__', ()): (74)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _NumberCodes = Literal[_IntegerCodes, _InexactCodes] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (400)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, _LiteralGenericAlias): (2)
 params.extend(p.__args__) (2)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (199)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (397)
 a for a in args) (396)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (198)
 if isinstance(t, type): (197)
 elif isinstance(t, tuple): (197)
 elif hasattr(t, '__typing_subst__'): (197)
 if _is_unpacked_typevartuple(t): (197)
 return ((not isinstance(x, type)) and (394)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (197)
 for x in getattr(t, '__parameters__', ()): (197)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _CharacterCodes = Literal[_StrCodes, _BytesCodes] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (36)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, _LiteralGenericAlias): (2)
 params.extend(p.__args__) (2)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (17)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (33)
 a for a in args) (32)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (16)
 if isinstance(t, type): (15)
 elif isinstance(t, tuple): (15)
 elif hasattr(t, '__typing_subst__'): (15)
 if _is_unpacked_typevartuple(t): (15)
 return ((not isinstance(x, type)) and (30)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (15)
 for x in getattr(t, '__parameters__', ()): (15)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _FlexibleCodes = Literal[_VoidCodes, _CharacterCodes] (1)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (48)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, _LiteralGenericAlias): (2)
 params.extend(p.__args__) (2)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (23)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (45)
 a for a in args) (44)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (22)
 if isinstance(t, type): (21)
 elif isinstance(t, tuple): (21)
 elif hasattr(t, '__typing_subst__'): (21)
 if _is_unpacked_typevartuple(t): (21)
 return ((not isinstance(x, type)) and (42)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (21)
 for x in getattr(t, '__parameters__', ()): (21)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _GenericCodes = Literal[ (2)
typing.py (1) if not isinstance(parameters, tuple): (1)
 return self._getitem(self, *parameters) (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (6)
 return ((p, type(p)) for p in parameters) (1058)
 parameters = _flatten_literal_params(parameters) (1)
 params = [] (1)
 for p in parameters: (7)
 if isinstance(p, _LiteralGenericAlias): (6)
 params.extend(p.__args__) (6)
 return tuple(params) (1)
 try: (1)
 parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) (524)
 try: (1)
 return dict.fromkeys(params) (1)
 return _LiteralGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (1047)
 a for a in args) (1046)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (523)
 if isinstance(t, type): (522)
 elif isinstance(t, tuple): (522)
 elif hasattr(t, '__typing_subst__'): (522)
 if _is_unpacked_typevartuple(t): (522)
 return ((not isinstance(x, type)) and (1044)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (522)
 for x in getattr(t, '__parameters__', ()): (522)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _BoolCodes, (2)
 _NumberCodes, (1)
 _FlexibleCodes, (1)
 _DT64Codes, (1)
 _TD64Codes, (1)
 _ObjectCodes, (1)

_scalars.py (1) from typing import Any, TypeAlias (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 import numpy as np (1)

_shape.py (1) from collections.abc import Sequence (1)
 from typing import SupportsIndex, TypeAlias (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 _Shape: TypeAlias = tuple[int, ...] (1)
 _ShapeLike: TypeAlias = SupportsIndex | Sequence[SupportsIndex] (1)

_dtype_like.py (1) from collections.abc import Sequence  # noqa: F811 (1)
 from typing import ( (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 import numpy as np (1)

_array_like.py (1) from __future__ import annotations (1)
 import sys (1)
 from collections.abc import Collection, Callable, Sequence (1)
 from typing import Any, Protocol, TypeAlias, TypeVar, runtime_checkable, TYPE_CHECKING (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 import numpy as np (1)

_ufunc.py (1) from .. import ufunc (1)

_function_base_impl.py (1) import builtins (1)
 import collections.abc (1)
 import functools (1)
 import re (1)
 import sys (1)
 import warnings (1)
 import numpy as np (1)

_histograms_impl.py (1) """ (1)
 import contextlib (1)
 import functools (1)
 import operator (1)
 import warnings (1)
 import numpy as np (1)

_nanfunctions_impl.py (1) """ (1)
 import functools (1)
 import warnings (1)
 import numpy as np (1)

_shape_base_impl.py (1) import functools (1)
 import warnings (1)
 import numpy._core.numeric as _nx (1)

_arraysetops_impl.py (1) """ (1)
 import functools (1)
 import warnings (1)
 from typing import NamedTuple (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 import numpy as np (1)

_polynomial_impl.py (1) """ (1)
 __all__ = ['poly', 'roots', 'polyint', 'polyder', 'polyadd', (1)
 import functools (1)
 import re (1)
 import warnings (1)
 from .._utils import set_module (1)

_arrayterator_impl.py (1) """ (1)
 from operator import mul (1)
 from functools import reduce (1)
 __all__ = ['Arrayterator'] (1)
 class Arrayterator: (2)
 """ (1)
 __module__ = "numpy.lib" (1)
 def __init__(self, var, buf_size=None): (1)
 def __getattr__(self, attr): (1)
 def __getitem__(self, index): (1)
 def __array__(self, dtype=None, copy=None): (1)
 @property (2)
 def flat(self): (2)
 @property (2)
 def shape(self): (2)
 def __iter__(self): (1)

_arraypad_impl.py (1) """ (1)
 import numpy as np (1)

_version.py (1) """Utility to compare (NumPy) version strings. (1)
 import re (1)
 __all__ = ['NumpyVersion'] (1)
 class NumpyVersion: (2)
 """Parse and compare numpy version strings. (1)
 __module__ = "numpy.lib" (1)
 def __init__(self, vstring): (1)
 def _compare_version(self, other): (1)
 def _compare_pre_release(self, other): (1)
 def _compare(self, other): (1)
 def __lt__(self, other): (1)
 def __le__(self, other): (1)
 def __eq__(self, other): (1)
 def __ne__(self, other): (1)
 def __gt__(self, other): (1)
 def __ge__(self, other): (1)
 def __repr__(self): (1)

_array_api_info.py (1) """ (1)
 from numpy._core import ( (1)

 (97)
 (97)
 (720)
<frozen importlib._bootstrap_external> (616) (428)
 (371)
 (337)
 (337)
 (345)
 (345)
 (345)
 (345)
 (1035)
 (690)
 (345)
 (345)
 (345)
 (345)
 (345)
 (1035)
 (345)
 (345)
 (337)
 (34)
 (34)
 (34)
 (34)
 (45)
 (44)
 (44)
 (44)
 (44)
 (44)
 (44)
 (44)
 (33)
 (33)
 (33)
 (33)
 (33)
 (127)
 (33)
 (33)
 (33)
 (33)
 (33)
 (33)
 (2)
 (6)
 (6)
 (6)
 (6)
 (94)
 (94)
 (94)
 (4)
 (4)
 (90)
 (2)
 (90)
 (86)
 (86)
 (180)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (90)
 (184)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (88)
 (176)
 (88)
 (1)
 (4)
 (4)
 (4)

 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
<frozen importlib._bootstrap_external> (97) (96)
 (96)
 (96)
 (96)
 (96)
 (96)
 (96)
 (96)
 (96)
 (97)
 (97)
 (96)
 (1)
 (1)
 (1)
 (1)
 (1)

 (100)
 (100)
 (101)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
<frozen importlib._bootstrap_external> (96) (92)
 (8)
 (4)

 (100)
 (92)
 (92)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (296)
 (99)
__init__.py (27) try: (1)
 __NUMPY_SETUP__ (1)
 except NameError: (1)
 __NUMPY_SETUP__ = False (1)
 if __NUMPY_SETUP__: (1)
 from . import _distributor_init (1)
 multiarray.set_typeDict(nt.sctypeDict) (1)
 from . import numeric (1)
 from . import fromnumeric (1)
 from .records import record, recarray (1)
 from . import _machar (1)
 from . import shape_base (1)
 from . import einsumfunc (1)
 del nt (1)
 from .numeric import absolute as abs (1)
 from . import _add_newdocs (1)
 __all__ = _linalg.__all__.copy() (1)
 from numpy._pytesttester import PytestTester (1)
 test = PytestTester(__name__) (1)
_pytesttester.py (1) self.module_name = module_name (1)
 self.__module__ = module_name (1)

 del PytestTester (1)
 __all__ = defmatrix.__all__ (1)
 from numpy._pytesttester import PytestTester (1)
 test = PytestTester(__name__) (1)
_pytesttester.py (1) self.module_name = module_name (1)
 self.__module__ = module_name (1)

 del PytestTester (1)
 from ._version import NumpyVersion (1)
 from numpy._core._multiarray_umath import add_docstring, tracemalloc_domain (1)
 from numpy._core.function_base import add_newdoc (1)
 __all__ = [ (1)
 add_newdoc.__module__ = "numpy.lib" (1)
 from numpy._pytesttester import PytestTester (1)
 test = PytestTester(__name__) (1)
_pytesttester.py (1) self.module_name = module_name (1)
 self.__module__ = module_name (1)

 del PytestTester (1)
 def __getattr__(attr): (1)
 from .lib._nanfunctions_impl import ( (1)
 from .lib._function_base_impl import ( (1)
 from .lib._twodim_base_impl import ( (1)
 from .lib._shape_base_impl import ( (1)
 from .lib._type_check_impl import ( (1)
 from .lib._arraysetops_impl import ( (1)
 from .lib._ufunclike_impl import fix, isneginf, isposinf (1)
 from .lib._arraypad_impl import pad (1)
 from .lib._utils_impl import ( (1)
 from .lib._stride_tricks_impl import ( (1)
 from .lib._polynomial_impl import ( (1)
 from .lib._npyio_impl import ( (1)
 from .lib._index_tricks_impl import ( (1)
 from . import matrixlib as _mat (1)

 (100)
 (100)
 (100)
 (100)
 (8)
 (8)
 (100)
 (106)
_distributor_init.py (1) except ImportError: (1)
 pass (1)

_add_newdocs_scalars.py (5) except AttributeError: (4)
 pass (4)
 for alias, doc in aliases: (6)
 try: (5)
 alias_type = getattr(_numerictypes, alias) (5)
 yield (alias_type, alias, doc) (2)
 def _get_platform_and_machine(): (1)
 _system, _machine = _get_platform_and_machine() (1)
 try: (1)
 system, _, _, _, machine = os.uname() (1)
 except AttributeError: (1)
 system = sys.platform (1)
 if system == 'win32': (1)
 machine = os.environ.get('PROCESSOR_ARCHITEW6432', '') \ (2)
<frozen _collections_abc> (1) (1)
 (1)
<frozen os> (1) (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)

 (1)
 (1)

 or os.environ.get('PROCESSOR_ARCHITECTURE', '') (1)
<frozen _collections_abc> (1) (1)
 (1)
<frozen os> (1) (1)
 (1)
 (1)
 (1)
 (1)
 (1)


 return system, machine (1)
 _doc_alias_string = f":Alias on this platform ({_system} {_machine}):" (1)
 def add_newdoc_for_scalar_type(obj, fixed_aliases, doc): (1)
 """ (1)
 _bool_docstring = ( (1)
 add_newdoc_for_scalar_type('bool', [], _bool_docstring) (1)
 o = getattr(_numerictypes, obj) (25)
 character_code = dtype(o).char (25)
 canonical_name_doc = "" if obj == o.__name__ else \ (39)
 if fixed_aliases: (25)
 alias_doc = '' (25)
 alias_doc += ''.join(f"{_doc_alias_string} `numpy.{alias}`: {doc}.\n    " (450)
 for (alias_type, alias, doc) in possible_aliases if alias_type is o) (425)
 docstring = f""" (50)
 {doc.strip()} (25)
 :Character code: ``'{character_code}'`` (25)
 {canonical_name_doc}{alias_doc} (25)
 add_newdoc('numpy._core.numerictypes', obj, docstring) (25)
function_base.py (25) new = getattr(__import__(place, globals(), {}, [obj]), obj) (25)
 if isinstance(doc, str): (25)
 if "${ARRAY_FUNCTION_LIKE}" in doc: (25)
 _add_docstring(new, doc.strip(), warn_on_python) (25)
 if warn_on_python and not _needs_add_docstring(obj): (25)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (25)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (25)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (25)
 return True (25)
 try: (25)
 add_docstring(obj, doc) (25)
 except Exception: (3)
 pass (3)

 add_newdoc_for_scalar_type('bool_', [], _bool_docstring) (1)
 f":Canonical name: `numpy.{obj}`\n    " (14)
 add_newdoc_for_scalar_type('byte', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('short', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('intc', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('int_', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('longlong', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('ubyte', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('ushort', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('uintc', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('uint', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('ulonglong', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('half', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('single', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('double', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('longdouble', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('csingle', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('cdouble', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('clongdouble', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('object_', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('str_', [], (2)
 r""" (1)
 add_newdoc_for_scalar_type('bytes_', [], (2)
 r""" (1)
 add_newdoc_for_scalar_type('void', [], (2)
 r""" (1)
 add_newdoc_for_scalar_type('datetime64', [], (2)
 """ (1)
 add_newdoc_for_scalar_type('timedelta64', [], (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', "integer", ('is_integer', (1)
function_base.py (1) new = getattr(__import__(place, globals(), {}, [obj]), obj) (1)
 if isinstance(doc, str): (1)
 elif isinstance(doc, tuple): (1)
 attr, docstring = doc (1)
 _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) (1)
 if warn_on_python and not _needs_add_docstring(obj): (1)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (1)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (1)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (1)
 return True (1)
 try: (1)
 add_docstring(obj, doc) (1)

 for float_name in ('half', 'single', 'double', 'longdouble'): (5)
 add_newdoc('numpy._core.numerictypes', float_name, ('as_integer_ratio', (8)
function_base.py (4) new = getattr(__import__(place, globals(), {}, [obj]), obj) (4)
 if isinstance(doc, str): (4)
 elif isinstance(doc, tuple): (4)
 attr, docstring = doc (4)
 _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) (4)
 if warn_on_python and not _needs_add_docstring(obj): (4)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (4)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (4)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (4)
 return True (4)
 try: (4)
 add_docstring(obj, doc) (4)

 """ (4)
 """.format(ftype=float_name))) (4)
 add_newdoc('numpy._core.numerictypes', float_name, ('is_integer', (8)
function_base.py (4) new = getattr(__import__(place, globals(), {}, [obj]), obj) (4)
 if isinstance(doc, str): (4)
 elif isinstance(doc, tuple): (4)
 attr, docstring = doc (4)
 _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) (4)
 if warn_on_python and not _needs_add_docstring(obj): (4)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (4)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (4)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (4)
 return True (4)
 try: (4)
 add_docstring(obj, doc) (4)

 f""" (8)
 {float_name}.is_integer() -> bool (4)
 >>> np.{float_name}(-2.0).is_integer() (4)
 >>> np.{float_name}(3.2).is_integer() (4)
 for int_name in ('int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', (13)
 add_newdoc('numpy._core.numerictypes', int_name, ('bit_count', (24)
function_base.py (12) new = getattr(__import__(place, globals(), {}, [obj]), obj) (12)
 if isinstance(doc, str): (12)
 elif isinstance(doc, tuple): (12)
 attr, docstring = doc (12)
 _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) (12)
 if warn_on_python and not _needs_add_docstring(obj): (12)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (12)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (12)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (12)
 return True (12)
 try: (12)
 add_docstring(obj, doc) (12)

 f""" (36)
 {int_name}.bit_count() -> int (12)
 >>> np.{int_name}(127).bit_count() (12)
 """ if dtype(int_name).char.islower() else ""))) (12)
 (f""" (12)
 >>> np.{int_name}(-127).bit_count() (6)

 (96)
 (94)
 (94)
 (96)
 (96)
 (188)
 (96)
 (96)
 (96)
<frozen importlib._bootstrap_external> (96) (96)
 (92)
 (92)
 (92)
 (92)
 (92)
 (368)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (368)
 (276)
 (92)
 (92)
 (184)
 (184)
 (184)
 (368)
 (92)
 (92)
 (4)
 (4)

 (188)
 (92)
 (92)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
<frozen importlib._bootstrap_external> (96) (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (368)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (368)
 (276)
 (92)
 (92)
 (184)
 (184)
 (184)
 (368)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (184)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (276)
 (276)
 (92)
 (92)
 (92)
 (92)
 (92)
 (184)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (92)
 (184)
 (92)
 (4)

 (87)
 (87)
 (86)
 (86)
 (86)
 (86)
 (86)
 (85)
 (197)
multiarray.py (2) from ._multiarray_umath import ( (1)
 __all__ = [ (1)
 _reconstruct.__module__ = 'numpy._core.multiarray' (1)
 scalar.__module__ = 'numpy._core.multiarray' (1)
 from_dlpack.__module__ = 'numpy' (1)
 arange.__module__ = 'numpy' (1)
 array.__module__ = 'numpy' (1)
 asarray.__module__ = 'numpy' (1)
 asanyarray.__module__ = 'numpy' (1)
 ascontiguousarray.__module__ = 'numpy' (1)
 asfortranarray.__module__ = 'numpy' (1)
 datetime_data.__module__ = 'numpy' (1)
 empty.__module__ = 'numpy' (1)
 frombuffer.__module__ = 'numpy' (1)
 fromfile.__module__ = 'numpy' (1)
 fromiter.__module__ = 'numpy' (1)
 frompyfunc.__module__ = 'numpy' (1)
 fromstring.__module__ = 'numpy' (1)
 may_share_memory.__module__ = 'numpy' (1)
 nested_iters.__module__ = 'numpy' (1)
 promote_types.__module__ = 'numpy' (1)
 zeros.__module__ = 'numpy' (1)
 normalize_axis_index.__module__ = 'numpy.lib.array_utils' (1)
 add_docstring.__module__ = 'numpy.lib' (1)
 compare_chararrays.__module__ = 'numpy.char' (1)
 def _override___module__(): (1)
 _override___module__() (1)
 namespace_names = globals() (1)
 for ufunc_name in [ (91)
 ufunc = namespace_names[ufunc_name] (90)
 ufunc.__module__ = "numpy" (90)
 ufunc.__qualname__ = ufunc_name (90)
 array_function_from_c_func_and_dispatcher = functools.partial( (2)
 overrides.array_function_from_dispatcher, (1)
 module='numpy', docs_from_dispatcher=True, verify=False) (1)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.empty_like) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 prototype, dtype=None, order=None, subok=None, shape=None, *, device=None (2)
 def empty_like( (3)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.concatenate) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def concatenate(arrays, axis=None, out=None, *, dtype=None, casting=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.inner) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def inner(a, b): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.where) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def where(condition, x=None, y=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.lexsort) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def lexsort(keys, axis=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.can_cast) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def can_cast(from_, to, casting=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.min_scalar_type) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def min_scalar_type(a): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.result_type) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def result_type(*arrays_and_dtypes): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.dot) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def dot(a, b, out=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.vdot) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vdot(a, b): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.bincount) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def bincount(x, weights=None, minlength=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.ravel_multi_index) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ravel_multi_index(multi_index, dims, mode=None, order=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.unravel_index) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unravel_index(indices, shape=None, order=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.copyto) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def copyto(dst, src, casting=None, where=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.putmask) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def putmask(a, /, mask, values): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.packbits) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def packbits(a, axis=None, bitorder='big'): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.unpackbits) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unpackbits(a, axis=None, count=None, bitorder='big'): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.shares_memory) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def shares_memory(a, b, max_work=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.may_share_memory) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def may_share_memory(a, b, max_work=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.is_busday) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def is_busday(dates, weekmask=None, holidays=None, busdaycal=None, out=None): (2)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_offset) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def busday_offset(dates, offsets, roll=None, weekmask=None, holidays=None, (3)
 busdaycal=None, out=None): (1)
 @array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_count) (2)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def busday_count(begindates, enddates, weekmask=None, holidays=None, (3)
 busdaycal=None, out=None): (1)
 @array_function_from_c_func_and_dispatcher( (3)
overrides.py (2) def decorator(dispatcher): (1)
 return decorator (1)
 return array_function_dispatch( (3)
 dispatcher, module, verify=verify, (1)
 docs_from_dispatcher=docs_from_dispatcher)(implementation) (2)
 def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 add_docstring(implementation, dispatcher.__doc__) (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (4)
 except AttributeError: (2)
 pass (2)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 _multiarray_umath.datetime_as_string) (1)
 def datetime_as_string(arr, unit=None, timezone=None, casting=None): (2)

umath.py (3) from ._multiarray_umath import ( (1)
 from ._multiarray_umath import ( (1)
 __all__ = [ (1)

numerictypes.py (1) from .._utils import set_module (1)

numeric.py (10) from . import overrides (1)
 from .umath import (multiply, invert, sin, PINF, NAN) (1)
 from . import numerictypes (1)
 from ._ufunc_config import errstate (1)
 from .numerictypes import * (1)
 from . import fromnumeric (1)
 from . import arrayprint (1)
 from . import _asarray (1)
 from . import _ufunc_config (1)
 extend_all(fromnumeric) (1)
 existing = set(__all__) (6)
 mall = module.__all__ (6)
 for a in mall: (224)
 if a not in existing: (218)
 __all__.append(a) (217)
 extend_all(umath) (1)
 extend_all(numerictypes) (1)
 extend_all(arrayprint) (1)
 extend_all(_asarray) (1)
 extend_all(_ufunc_config) (1)

shape_base.py (1) from . import fromnumeric as _from_nx (1)

fromnumeric.py (2) from ._multiarray_umath import _array_converter (1)
 from . import _methods (1)

_ufunc_config.py (1) __all__ = [ (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def seterr(all=None, divide=None, over=None, under=None, invalid=None): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def geterr(): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def setbufsize(size): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def getbufsize(): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def seterrcall(func): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def geterrcall(): (2)
 class _unspecified: (2)
 pass (1)
 _Unspecified = _unspecified() (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class errstate: (2)
 """ (1)
 __slots__ = ( (1)
 def __init__(self, *, call=_Unspecified, (2)
 all=None, divide=None, over=None, under=None, invalid=None): (1)
 def __enter__(self): (1)
 def __exit__(self, *exc_info): (1)
 def __call__(self, func): (1)

arrayprint.py (6) from . import multiarray (1)
 from .fromnumeric import any (1)
 from .numeric import concatenate, asarray, errstate (1)
 from .overrides import array_function_dispatch, set_module (1)
 from .printoptions import format_options (1)
 import operator (1)
 import warnings (1)
 import contextlib (1)
 def _make_options_dict(precision=None, threshold=None, edgeitems=None, (2)
 linewidth=None, suppress=None, nanstr=None, infstr=None, (1)
 sign=None, formatter=None, floatmode=None, legacy=None, (1)
 override_repr=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def set_printoptions(precision=None, threshold=None, edgeitems=None, (4)
 linewidth=None, suppress=None, nanstr=None, (1)
 infstr=None, formatter=None, sign=None, floatmode=None, (1)
 *, legacy=None, override_repr=None): (1)
 def _set_printoptions(precision=None, threshold=None, edgeitems=None, (3)
 linewidth=None, suppress=None, nanstr=None, (1)
 infstr=None, formatter=None, sign=None, floatmode=None, (1)
 *, legacy=None, override_repr=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def get_printoptions(): (2)
 def _get_legacy_print_mode(): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @contextlib.contextmanager (2)
contextlib.py (1) @wraps(func) (2)
functools.py (2) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 def helper(*args, **kwds): (2)
 return helper (1)

 def printoptions(*args, **kwargs): (2)
 def _leading_trailing(a, edgeitems, index=()): (1)
 def _object_format(o): (1)
 def repr_format(x): (1)
 def str_format(x): (1)
 def _get_formatdict(data, *, precision, floatmode, suppress, sign, legacy, (1)
 def _get_format_function(data, **options): (1)
 def _recursive_guard(fillvalue='...'): (1)
 @_recursive_guard() (2)
 def decorating_function(f): (2)
 return decorating_function (2)
 def _array2string(a, options, separator=' ', prefix=""): (2)
 repr_running = set() (2)
 @functools.wraps(f) (4)
functools.py (4) return partial(update_wrapper, wrapped=wrapped, (4)
 assigned=assigned, updated=updated) (2)
 for attr in assigned: (14)
 try: (12)
 value = getattr(wrapped, attr) (12)
 setattr(wrapper, attr, value) (12)
 for attr in updated: (4)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (2)
 wrapper.__wrapped__ = wrapped (2)
 return wrapper (2)

 def wrapper(self, *args, **kwargs): (4)
 return wrapper (2)
 a, max_line_width=None, precision=None, (1)
 suppress_small=None, separator=None, prefix=None, (1)
 style=None, formatter=None, threshold=None, (1)
 edgeitems=None, sign=None, floatmode=None, suffix=None, (1)
 def _array2string_dispatcher( (2)
 *, legacy=None): (1)
 @array_function_dispatch(_array2string_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (14)
 if args[i][:1] in ['', '.']: (13)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (14)
 if args[i][:1] in ['', '.']: (13)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array2string(a, max_line_width=None, precision=None, (4)
 suppress_small=None, separator=' ', prefix="", (1)
 style=np._NoValue, formatter=None, threshold=None, (1)
 edgeitems=None, sign=None, floatmode=None, suffix="", (1)
 *, legacy=None): (1)
 def _extendLine(s, line, word, line_width, next_line_prefix, legacy): (1)
 def _extendLine_pretty(s, line, word, line_width, next_line_prefix, legacy): (1)
 def _formatArray(a, format_function, line_width, next_line_prefix, (1)
 def _none_or_positive_arg(x, name): (1)
 class FloatingFormat: (2)
 """ Formatter for subtypes of np.floating """ (1)
 def __init__(self, data, precision, floatmode, suppress_small, sign=False, (2)
 *, legacy=None): (1)
 def fillFormat(self, data): (1)
 def __call__(self, x): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def format_float_scientific(x, precision=None, unique=True, trim='k', (3)
 sign=False, pad_left=None, exp_digits=None, (1)
 min_digits=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def format_float_positional(x, precision=None, unique=True, (3)
 fractional=True, trim='k', sign=False, (1)
 pad_left=None, pad_right=None, min_digits=None): (1)
 class IntegerFormat: (2)
 def __init__(self, data, sign='-'): (1)
 def __call__(self, x): (1)
 class BoolFormat: (2)
 def __init__(self, data, **kwargs): (1)
 def __call__(self, x): (1)
 class ComplexFloatingFormat: (2)
 """ Formatter for subtypes of np.complexfloating """ (1)
 sign=False, *, legacy=None): (2)
 def __init__(self, x, precision, floatmode, suppress_small, (2)
 def __call__(self, x): (1)
 class _TimelikeFormat: (2)
 def __init__(self, data): (1)
 def _format_non_nat(self, x): (1)
 def __call__(self, x): (1)
 class DatetimeFormat(_TimelikeFormat): (2)
 def __init__(self, x, unit=None, timezone=None, casting='same_kind', (2)
 legacy=False): (1)
 def __call__(self, x): (1)
 def _format_non_nat(self, x): (1)
 class TimedeltaFormat(_TimelikeFormat): (2)
 def _format_non_nat(self, x): (1)
 class SubArrayFormat: (2)
 def __init__(self, format_function, **options): (1)
 def __call__(self, a): (1)
 def format_array(self, a): (1)
 class StructuredVoidFormat: (2)
 """ (1)
 def __init__(self, format_functions): (1)
 @classmethod (2)
 def from_data(cls, data, **options): (2)
 def __call__(self, x): (1)
 def _void_scalar_to_string(x, is_repr=True): (1)
 _typelessdata = [int_, float64, complex128, _nt.bool] (1)
 def dtype_is_implied(dtype): (1)
 def dtype_short_repr(dtype): (1)
 arr, max_line_width=None, precision=None, suppress_small=None, (1)
 array2string=array2string): (1)
 def _array_repr_implementation( (1)
 arr, max_line_width=None, precision=None, suppress_small=None): (1)
 def _array_repr_dispatcher( (1)
 @array_function_dispatch(_array_repr_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array_repr(arr, max_line_width=None, precision=None, suppress_small=None): (2)
 @_recursive_guard() (2)
 def _guarded_repr_or_str(v): (2)
 a, max_line_width=None, precision=None, suppress_small=None, (1)
 array2string=array2string): (1)
 def _array_str_implementation( (1)
 a, max_line_width=None, precision=None, suppress_small=None): (1)
 def _array_str_dispatcher( (1)
 @array_function_dispatch(_array_str_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array_str(a, max_line_width=None, precision=None, suppress_small=None): (2)
 _array2string_impl = getattr(array2string, '__wrapped__', array2string) (1)
 _default_array_str = functools.partial(_array_str_implementation, (2)
 array2string=_array2string_impl) (1)
 _default_array_repr = functools.partial(_array_repr_implementation, (2)
 array2string=_array2string_impl) (1)

_asarray.py (2) from .multiarray import array, asanyarray (1)
 __all__ = ["require"] (1)
 'C': 'C', 'C_CONTIGUOUS': 'C', 'CONTIGUOUS': 'C', (1)
 'F': 'F', 'F_CONTIGUOUS': 'F', 'FORTRAN': 'F', (1)
 'A': 'A', 'ALIGNED': 'A', (1)
 'W': 'W', 'WRITEABLE': 'W', (1)
 'O': 'O', 'OWNDATA': 'O', (1)
 'E': 'E', 'ENSUREARRAY': 'E' (1)
 POSSIBLE_FLAGS = { (1)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def require(a, dtype=None, requirements=None, *, like=None): (2)
 _require_with_like = array_function_dispatch()(require) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)


records.py (1) __all__ = [ (1)
 ndarray = sb.ndarray (1)
 _byteorderconv = {'b': '>', (2)
 'l': '<', (1)
 'n': '=', (1)
 'B': '>', (1)
 'L': '<', (1)
 'N': '=', (1)
 'S': 's', (1)
 's': 's', (1)
 '>': '>', (1)
 '<': '<', (1)
 '=': '=', (1)
 '|': '|', (1)
 'I': '|', (1)
 'i': '|'} (1)
 numfmt = nt.sctypeDict (1)
 @set_module('numpy.rec') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def find_duplicate(list): (2)
 @set_module('numpy.rec') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class format_parser: (2)
 """ (1)
 def __init__(self, formats, names, titles, aligned=False, byteorder=None): (1)
 def _parseFormats(self, formats, aligned=False): (1)
 def _setfieldnames(self, names, titles): (1)
 def _createdtype(self, byteorder): (1)
 class record(nt.void): (2)
 """A data-type scalar that allows field access as attribute lookup. (1)
 __name__ = 'record' (1)
 __module__ = 'numpy' (1)
 def __repr__(self): (1)
 def __str__(self): (1)
 def __getattribute__(self, attr): (1)
 def __setattr__(self, attr, val): (1)
 def __getitem__(self, indx): (1)
 def pprint(self): (1)
 @set_module("numpy.rec") (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class recarray(ndarray): (2)
 """Construct an ndarray that allows field access using attributes. (1)
 def __new__(subtype, shape, dtype=None, buf=None, offset=0, strides=None, (2)
 formats=None, names=None, titles=None, (1)
 byteorder=None, aligned=False, order='C'): (1)
 def __array_finalize__(self, obj): (1)
 def __getattribute__(self, attr): (1)
 def __setattr__(self, attr, val): (1)
 def __getitem__(self, indx): (1)
 def __repr__(self): (1)
 def field(self, attr, val=None): (1)
 def _deprecate_shape_0_as_None(shape): (1)
 @set_module("numpy.rec") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromarrays(arrayList, dtype=None, shape=None, formats=None, (3)
 names=None, titles=None, aligned=False, byteorder=None): (1)
 @set_module("numpy.rec") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromrecords(recList, dtype=None, shape=None, formats=None, names=None, (3)
 titles=None, aligned=False, byteorder=None): (1)
 @set_module("numpy.rec") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, (3)
 names=None, titles=None, aligned=False, byteorder=None): (1)
 def get_remaining_size(fd): (1)
 @set_module("numpy.rec") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromfile(fd, dtype=None, shape=None, offset=0, formats=None, (3)
 names=None, titles=None, aligned=False, byteorder=None): (1)
 @set_module("numpy.rec") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def array(obj, dtype=None, shape=None, offset=0, strides=None, formats=None, (3)
 names=None, titles=None, aligned=False, byteorder=None, copy=True): (1)

memmap.py (1) __all__ = ['memmap'] (1)
 dtypedescr = dtype (1)
 valid_filemodes = ["r", "c", "r+", "w+"] (1)
 writeable_filemodes = ["r+", "w+"] (1)
 "readonly":"r", (1)
 "copyonwrite":"c", (1)
 "readwrite":"r+", (1)
 "write":"w+" (1)
 mode_equivalents = { (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class memmap(ndarray): (2)
 """Create a memory-map to an array stored in a *binary* file on disk. (1)
 __array_priority__ = -100.0 (1)
 def __new__(subtype, filename, dtype=uint8, mode='r+', offset=0, (2)
 shape=None, order='C'): (1)
 def __array_finalize__(self, obj): (1)
 def flush(self): (1)
 def __array_wrap__(self, arr, context=None, return_scalar=False): (1)
 def __getitem__(self, index): (1)

function_base.py (1) from numpy._core.multiarray import add_docstring (1)
 from numpy._core._multiarray_umath import _array_converter (1)
 from numpy._core import overrides (1)

_machar.py (2) from ._ufunc_config import errstate (1)
 from .._utils import set_module (1)

getlimits.py (3) from . import numeric (1)
 from .umath import log10, exp2, nextafter, isnan (1)
 def _fr0(a): (1)
 def _fr1(a): (1)
 class MachArLike: (2)
 """ Object to simulate MachAr instance """ (1)
 ibeta, smallest_subnormal=None, **kwargs): (1)
 def __init__(self, ftype, *, eps, epsneg, huge, tiny, (1)
 @property (2)
 def smallest_subnormal(self): (2)
 @property (2)
 def _str_smallest_subnormal(self): (2)
 def _float_to_float(self, value): (1)
 def _float_conv(self, value): (1)
 def _float_to_str(self, value): (1)
 ntypes.csingle: ntypes.single, (1)
 ntypes.complex128: ntypes.float64, (1)
 ntypes.clongdouble: ntypes.longdouble (1)
 _convert_to_float = { (1)
 _title_fmt = 'numpy {} precision floating point number' (1)
 ntypes.double: dict( (2)
 itype = ntypes.int64, (1)
 fmt = '%24.16e', (1)
 title = _title_fmt.format('double')), (1)
 ntypes.single: dict( (2)
 itype = ntypes.int32, (1)
 fmt = '%15.7e', (1)
 title = _title_fmt.format('single')), (1)
 ntypes.longdouble: dict( (2)
 itype = ntypes.longlong, (1)
 fmt = '%s', (1)
 title = _title_fmt.format('long double')), (1)
 ntypes.half: dict( (2)
 itype = ntypes.int16, (1)
 fmt = '%12.5e', (1)
 title = _title_fmt.format('half'))} (1)
 _MACHAR_PARAMS = { (1)
 _KNOWN_TYPES = {} (1)
 def _register_type(machar, bytepat): (1)
 _float_ma = {} (1)
 def _register_known_types(): (1)
 def _get_machar(ftype): (1)
 def _discovered_machar(ftype): (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class finfo: (2)
 """ (1)
 _finfo_cache = {} (1)
 __class_getitem__ = classmethod(types.GenericAlias) (1)
 def __new__(cls, dtype): (1)
 def _init(self, dtype): (1)
 def __str__(self): (1)
 def __repr__(self): (1)
 @property (2)
 def smallest_normal(self): (2)
 @property (2)
 def tiny(self): (2)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class iinfo: (2)
 """ (1)
 _min_vals = {} (1)
 _max_vals = {} (1)
 __class_getitem__ = classmethod(types.GenericAlias) (1)
 def __init__(self, int_type): (1)
 @property (2)
 def min(self): (2)
 @property (2)
 def max(self): (2)
 def __str__(self): (1)
 def __repr__(self): (1)

_internal.py (2) from .multiarray import dtype, array, ndarray, promote_types, StringDType (1)
 from numpy import _NoValue (1)

_nbit.py (1) _NBitByte: TypeAlias = _8Bit (1)
 _NBitShort: TypeAlias = _16Bit (1)
 _NBitIntC: TypeAlias = _32Bit (1)
 _NBitIntP: TypeAlias = _32Bit | _64Bit (1)
 _NBitInt: TypeAlias = _NBitIntP (1)
 _NBitLong: TypeAlias = _32Bit | _64Bit (1)
 _NBitLongLong: TypeAlias = _64Bit (1)
 _NBitHalf: TypeAlias = _16Bit (1)
 _NBitSingle: TypeAlias = _32Bit (1)
 _NBitDouble: TypeAlias = _64Bit (1)
 _NBitLongDouble: TypeAlias = _64Bit | _96Bit | _128Bit (1)

_dtype_like.py (2) from ._char_codes import ( (1)
 _SCT = TypeVar("_SCT", bound=np.generic) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 _DType_co = TypeVar("_DType_co", covariant=True, bound=np.dtype[Any]) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 _DTypeLikeNested: TypeAlias = Any  # TODO: wait for support for recursive types (1)
 class _DTypeDictBase(TypedDict): (2)
typing.py (1) TypedDict.__mro_entries__ = lambda bases: (_TypedDict,) (1)

 names: Sequence[str] (1)
 formats: Sequence[_DTypeLikeNested] (1)
typing.py (1) for base in bases: (2)
 if type(base) is not _TypedDictMeta and base is not Generic: (1)
 if any(issubclass(b, Generic) for b in bases): (3)
 generic_base = () (1)
 tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict), ns) (1)
 if not hasattr(tp_dict, '__orig_bases__'): (1)
 annotations = {} (1)
 own_annotations = ns.get('__annotations__', {}) (1)
 msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type" (1)
 for n, tp in own_annotations.items() (4)
 own_annotations = { (2)
 n: _type_check(tp, msg, module=tp_dict.__module__) (2)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if arg is None: (2)
 if isinstance(arg, str): (2)
 return arg (2)
 if (isinstance(arg, _GenericAlias) and (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 required_keys = set() (1)
 optional_keys = set() (1)
 readonly_keys = set() (1)
 mutable_keys = set() (1)
 for base in bases: (2)
 annotations.update(base.__dict__.get('__annotations__', {})) (1)
 base_required = base.__dict__.get('__required_keys__', set()) (1)
 required_keys |= base_required (1)
 optional_keys -= base_required (1)
 base_optional = base.__dict__.get('__optional_keys__', set()) (1)
 required_keys -= base_optional (1)
 optional_keys |= base_optional (1)
 readonly_keys.update(base.__dict__.get('__readonly_keys__', ())) (1)
 mutable_keys.update(base.__dict__.get('__mutable_keys__', ())) (1)
 annotations.update(own_annotations) (1)
 for annotation_key, annotation_type in own_annotations.items(): (3)
 qualifiers = set(_get_typeddict_qualifiers(annotation_type)) (2)
 while True: (2)
 annotation_origin = get_origin(annotation_type) (2)
 if isinstance(tp, _AnnotatedAlias): (2)
 if isinstance(tp, (_BaseGenericAlias, GenericAlias, (4)
 ParamSpecArgs, ParamSpecKwargs)): (2)
 return tp.__origin__ (2)
 if annotation_origin is Annotated: (2)
 elif annotation_origin is Required: (2)
 elif annotation_origin is NotRequired: (2)
 elif annotation_origin is ReadOnly: (2)
 break (2)
 if Required in qualifiers: (2)
 elif NotRequired in qualifiers: (2)
 is_required = total (2)
 if is_required: (2)
 required_keys.add(annotation_key) (2)
 optional_keys.discard(annotation_key) (2)
 if ReadOnly in qualifiers: (2)
 mutable_keys.add(annotation_key) (2)
 readonly_keys.discard(annotation_key) (2)
 assert required_keys.isdisjoint(optional_keys), ( (1)
 tp_dict.__annotations__ = annotations (1)
 tp_dict.__required_keys__ = frozenset(required_keys) (1)
 tp_dict.__optional_keys__ = frozenset(optional_keys) (1)
 tp_dict.__readonly_keys__ = frozenset(readonly_keys) (1)
 tp_dict.__mutable_keys__ = frozenset(mutable_keys) (1)
 tp_dict.__total__ = total (1)
 return tp_dict (1)

 class _DTypeDict(_DTypeDictBase, total=False): (2)
 offsets: Sequence[int] (1)
 titles: Sequence[Any] (1)
 itemsize: int (1)
 aligned: bool (1)
typing.py (1) for base in bases: (2)
 if type(base) is not _TypedDictMeta and base is not Generic: (1)
 if any(issubclass(b, Generic) for b in bases): (3)
 generic_base = () (1)
 tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict), ns) (1)
 if not hasattr(tp_dict, '__orig_bases__'): (1)
 tp_dict.__orig_bases__ = bases (1)
 annotations = {} (1)
 own_annotations = ns.get('__annotations__', {}) (1)
 msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type" (1)
 for n, tp in own_annotations.items() (6)
 own_annotations = { (2)
 n: _type_check(tp, msg, module=tp_dict.__module__) (4)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 required_keys = set() (1)
 optional_keys = set() (1)
 readonly_keys = set() (1)
 mutable_keys = set() (1)
 for base in bases: (2)
 annotations.update(base.__dict__.get('__annotations__', {})) (1)
 base_required = base.__dict__.get('__required_keys__', set()) (1)
 required_keys |= base_required (1)
 optional_keys -= base_required (1)
 base_optional = base.__dict__.get('__optional_keys__', set()) (1)
 required_keys -= base_optional (1)
 optional_keys |= base_optional (1)
 readonly_keys.update(base.__dict__.get('__readonly_keys__', ())) (1)
 mutable_keys.update(base.__dict__.get('__mutable_keys__', ())) (1)
 annotations.update(own_annotations) (1)
 for annotation_key, annotation_type in own_annotations.items(): (5)
 qualifiers = set(_get_typeddict_qualifiers(annotation_type)) (4)
 while True: (4)
 annotation_origin = get_origin(annotation_type) (4)
 if isinstance(tp, _AnnotatedAlias): (4)
 if isinstance(tp, (_BaseGenericAlias, GenericAlias, (8)
 ParamSpecArgs, ParamSpecKwargs)): (4)
 return tp.__origin__ (2)
 if annotation_origin is Annotated: (4)
 elif annotation_origin is Required: (4)
 elif annotation_origin is NotRequired: (4)
 elif annotation_origin is ReadOnly: (4)
 break (4)
 if Required in qualifiers: (4)
 elif NotRequired in qualifiers: (4)
 is_required = total (4)
 if is_required: (4)
 optional_keys.add(annotation_key) (4)
 required_keys.discard(annotation_key) (4)
 if ReadOnly in qualifiers: (4)
 mutable_keys.add(annotation_key) (4)
 readonly_keys.discard(annotation_key) (4)
 if tp is Generic: (2)
 if isinstance(tp, types.UnionType): (2)
 return None (2)
 assert required_keys.isdisjoint(optional_keys), ( (1)
 tp_dict.__annotations__ = annotations (1)
 tp_dict.__required_keys__ = frozenset(required_keys) (1)
 tp_dict.__optional_keys__ = frozenset(optional_keys) (1)
 tp_dict.__readonly_keys__ = frozenset(readonly_keys) (1)
 tp_dict.__mutable_keys__ = frozenset(mutable_keys) (1)
 tp_dict.__total__ = total (1)
 return tp_dict (1)

 @runtime_checkable (3)
typing.py (1) if not issubclass(cls, Generic) or not getattr(cls, '_is_protocol', False): (1)
 cls._is_runtime_protocol = True (1)
 cls.__non_callable_proto_members__ = set() (1)
 for attr in cls.__protocol_attrs__: (2)
 try: (1)
 is_callable = callable(getattr(cls, attr, None)) (1)
 if not is_callable: (1)
 cls.__non_callable_proto_members__.add(attr) (1)
 return cls (1)

 class _SupportsDType(Protocol[_DType_co]): (2)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 if not args: (1)
 if not all(_is_typevar_like(p) for p in args): (3)
 return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x) (1)
 if len(set(args)) != len(args): (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if t not in parameters: (1)
 if enforce_default_ordering: (1)
 if type_var_tuple_encountered and t.has_default(): (1)
 if t.has_default(): (1)
 elif default_encountered: (1)
 parameters.append(t) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)
 if isinstance(self.__origin__, _SpecialForm): (1)
 if self._name:  # generic version of an ABC or built-in class (1)
 if self.__origin__ is Generic: (1)
 return (self.__origin__,) (1)

 @property (2)
 def dtype(self) -> _DType_co: ... (2)
typing.py (1) if name == "Protocol" and bases == (Generic,): (1)
 elif Protocol in bases: (1)
 for base in bases: (2)
 base in {object, Generic} (1)
 or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) (1)
 issubclass(base, Generic) (1)
 and getattr(base, "_is_protocol", False) (1)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (1)
<frozen abc> (1) (1)

 super().__init_subclass__(*args, **kwargs) (1)
 super(Generic, cls).__init_subclass__(*args, **kwargs) (1)
 tvars = [] (1)
 if '__orig_bases__' in cls.__dict__: (1)
 error = Generic in cls.__orig_bases__ (1)
 if not isinstance(other, _GenericAlias): (1)
 return NotImplemented (1)
 if error: (1)
 if '__orig_bases__' in cls.__dict__: (1)
 tvars = _collect_type_parameters(cls.__orig_bases__) (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 return attr.startswith('__') and attr.endswith('__') (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 gvars = None (1)
 for base in cls.__orig_bases__: (2)
 if (isinstance(base, _GenericAlias) and (1)
 base.__origin__ is Generic): (1)
 if gvars is not None: (1)
 cls.__parameters__ = tuple(tvars) (1)
 if not cls.__dict__.get('_is_protocol', False): (1)
 cls._is_protocol = any(b is Protocol for b in cls.__bases__) (2)
 if '__subclasshook__' not in cls.__dict__: (1)
 cls.__subclasshook__ = _proto_hook (1)
 if cls._is_protocol and cls.__init__ is Protocol.__init__: (1)
 cls.__init__ = _no_init_or_replace_init (1)
<frozen abc> (1) (1)
 (1)

 super().__init__(*args, **kwargs) (1)
 if getattr(cls, "_is_protocol", False): (1)
 cls.__protocol_attrs__ = _get_protocol_attrs(cls) (1)
 attrs = set() (1)
 for base in cls.__mro__[:-1]:  # without object (4)
 if base.__name__ in {'Protocol', 'Generic'}: (3)
 annotations = getattr(base, '__annotations__', {}) (1)
 for attr in (*base.__dict__, *annotations): (16)
 if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: (15)
 attrs.add(attr) (1)
 continue (2)
 return attrs (1)

 np.dtype[_SCT] (3)
typing.py (1) return Union[left, self] (1)
 try: (1)
 return _caches[func](*args, **kwds) (1)
 return hash((self.__origin__, self.__args__)) (2)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if arg is None: (2)
 if isinstance(arg, str): (2)
 return arg (2)
 if (isinstance(arg, _GenericAlias) and (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 arg.__origin__ in invalid_generic_forms): (1)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (2)
 params.extend(p.__args__) (1)
 params.append(p) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (9)
 a for a in args) (8)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (4)
 if isinstance(t, type): (3)
 elif isinstance(t, tuple): (3)
 elif hasattr(t, '__typing_subst__'): (3)
 if _is_unpacked_typevartuple(t): (3)
 return ((not isinstance(x, type)) and (6)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (3)
 for x in getattr(t, '__parameters__', ()): (6)
 if x not in parameters: (3)
 parameters.append(x) (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | type[_SCT] (1)
 | _SupportsDType[np.dtype[_SCT]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _DTypeLike: TypeAlias = ( (1)
 tuple[_DTypeLikeNested, int] (5)
 | tuple[_DTypeLikeNested, _ShapeLike] (1)
 | list[Any] (1)
 | _DTypeDict (1)
 | tuple[_DTypeLikeNested, _DTypeLikeNested] (1)
 _VoidDTypeLike: TypeAlias = ( (1)
 np.dtype[Any] (6)
typing.py (3) return Union[left, self] (1)
 try: (3)
 return _caches[func](*args, **kwds) (3)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (3)
 if parameters == (): (3)
 if not isinstance(parameters, tuple): (3)
 msg = "Union[arg, ...]: each arg must be a type." (3)
 parameters = tuple(_type_check(p, msg) for p in parameters) (12)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if arg is None: (6)
 if isinstance(arg, str): (6)
 return arg (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (3)
 params = [] (3)
 for p in parameters: (9)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (6)
 params.extend(p.__args__) (4)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (3)
 try: (3)
 return dict.fromkeys(params) (3)
 if len(parameters) == 1: (3)
 if len(parameters) == 2 and type(None) in parameters: (3)
 return _UnionGenericAlias(self, parameters) (3)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 return attr.startswith('__') and attr.endswith('__') (27)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (47)
 a for a in args) (44)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (22)
 if isinstance(t, type): (19)
 elif isinstance(t, tuple): (13)
 elif hasattr(t, '__typing_subst__'): (13)
 if _is_unpacked_typevartuple(t): (13)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 for x in getattr(t, '__parameters__', ()): (13)
 pass (6)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return Union[self, right] (2)
 return hash(frozenset(self.__args__)) (2)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (16)
 return NotImplemented (16)

 | None (1)
 | type[Any]  # NOTE: We're stuck with `type[Any]` due to object dtypes (1)
 | _SupportsDType[np.dtype[Any]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | str (1)
 | _VoidDTypeLike (1)
 DTypeLike: TypeAlias = ( (1)
 type[bool] (5)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (24)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (11)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (9)
 elif hasattr(t, '__typing_subst__'): (9)
 if _is_unpacked_typevartuple(t): (9)
 return ((not isinstance(x, type)) and (18)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (9)
 for x in getattr(t, '__parameters__', ()): (9)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (18)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | type[np.bool] (1)
 | np.dtype[np.bool] (1)
 | _SupportsDType[np.dtype[np.bool]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _BoolCodes (1)
 _DTypeLikeBool: TypeAlias = ( (1)
 type[np.unsignedinteger[Any]] (14)
typing.py (12) return Union[left, self] (1)
 try: (12)
 return _caches[func](*args, **kwds) (12)
 return hash((self.__origin__, self.__args__)) (24)
 return self._getitem(self, parameters) (12)
 if parameters == (): (12)
 if not isinstance(parameters, tuple): (12)
 msg = "Union[arg, ...]: each arg must be a type." (12)
 parameters = tuple(_type_check(p, msg) for p in parameters) (48)
 invalid_generic_forms = (Generic, Protocol) (24)
 if not allow_special_forms: (24)
 invalid_generic_forms += (ClassVar,) (24)
 if is_argument: (24)
 invalid_generic_forms += (Final,) (24)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (24)
 if arg is None: (24)
 if isinstance(arg, str): (24)
 return arg (24)
 if (isinstance(arg, _GenericAlias) and (24)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (24)
 if allow_special_forms and arg in (ClassVar, Final): (24)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (24)
 if type(arg) is tuple: (24)
 return arg (24)
 arg.__origin__ in invalid_generic_forms): (23)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (12)
 params = [] (12)
 for p in parameters: (36)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (24)
 params.extend(p.__args__) (12)
 params.append(p) (12)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (12)
 try: (12)
 return dict.fromkeys(params) (12)
 if len(parameters) == 1: (12)
 if len(parameters) == 2 and type(None) in parameters: (12)
 return _UnionGenericAlias(self, parameters) (12)
 super().__init__(origin, inst=inst, name=name) (12)
 self._inst = inst (12)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (84)
 return attr.startswith('__') and attr.endswith('__') (238)
 super().__setattr__(attr, val) (84)
 self._name = name (12)
 self.__origin__ = origin (12)
 self.__slots__ = None  # This is not documented. (12)
 if not isinstance(args, tuple): (12)
 self.__args__ = tuple(... if a is _TypingEllipsis else (238)
 a for a in args) (226)
 enforce_default_ordering = origin in (Generic, Protocol) (12)
 self.__parameters__ = _collect_type_parameters( (24)
 args, (12)
 enforce_default_ordering=enforce_default_ordering, (12)
 default_encountered = False (12)
 type_var_tuple_encountered = False (12)
 parameters = [] (12)
 for t in args: (113)
 if isinstance(t, type): (101)
 elif isinstance(t, tuple): (101)
 elif hasattr(t, '__typing_subst__'): (101)
 if _is_unpacked_typevartuple(t): (101)
 return ((not isinstance(x, type)) and (202)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (101)
 for x in getattr(t, '__parameters__', ()): (101)
 if attr in {'__name__', '__qualname__'}: (154)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (154)
 raise AttributeError(attr) (154)
 return tuple(parameters) (12)
 if not name: (12)
 self.__module__ = origin.__module__ (12)
 return Union[self, right] (11)
 return hash(frozenset(self.__args__)) (11)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (132)
 return ((p, type(p)) for p in parameters) (1062)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (88)
 return NotImplemented (88)
 if not isinstance(other, _LiteralGenericAlias): (88)
 return NotImplemented (88)

 | np.dtype[np.unsignedinteger[Any]] (1)
 | _SupportsDType[np.dtype[np.unsignedinteger[Any]]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _UInt8Codes (1)
 | _UInt16Codes (1)
 | _UInt32Codes (1)
 | _UInt64Codes (1)
 | _UByteCodes (1)
 | _UShortCodes (1)
 | _UIntCCodes (1)
 | _LongCodes (1)
 | _ULongLongCodes (1)
 | _UIntPCodes (1)
 | _UIntCodes (1)
 _DTypeLikeUInt: TypeAlias = ( (1)
 type[int] (15)
typing.py (12) return Union[left, self] (1)
 try: (12)
 return _caches[func](*args, **kwds) (12)
 return hash((self.__origin__, self.__args__)) (24)
 return self._getitem(self, parameters) (12)
 if parameters == (): (12)
 if not isinstance(parameters, tuple): (12)
 msg = "Union[arg, ...]: each arg must be a type." (12)
 parameters = tuple(_type_check(p, msg) for p in parameters) (48)
 invalid_generic_forms = (Generic, Protocol) (24)
 if not allow_special_forms: (24)
 invalid_generic_forms += (ClassVar,) (24)
 if is_argument: (24)
 invalid_generic_forms += (Final,) (24)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (24)
 if arg is None: (24)
 if isinstance(arg, str): (24)
 return arg (24)
 if (isinstance(arg, _GenericAlias) and (24)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (24)
 if allow_special_forms and arg in (ClassVar, Final): (24)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (24)
 if type(arg) is tuple: (24)
 return arg (24)
 arg.__origin__ in invalid_generic_forms): (23)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (12)
 params = [] (12)
 for p in parameters: (36)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (24)
 params.extend(p.__args__) (12)
 params.append(p) (12)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (12)
 try: (12)
 return dict.fromkeys(params) (12)
 if len(parameters) == 1: (12)
 if len(parameters) == 2 and type(None) in parameters: (12)
 return _UnionGenericAlias(self, parameters) (12)
 super().__init__(origin, inst=inst, name=name) (12)
 self._inst = inst (12)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (84)
 return attr.startswith('__') and attr.endswith('__') (238)
 super().__setattr__(attr, val) (84)
 self._name = name (12)
 self.__origin__ = origin (12)
 self.__slots__ = None  # This is not documented. (12)
 if not isinstance(args, tuple): (12)
 self.__args__ = tuple(... if a is _TypingEllipsis else (262)
 a for a in args) (250)
 enforce_default_ordering = origin in (Generic, Protocol) (12)
 self.__parameters__ = _collect_type_parameters( (24)
 args, (12)
 enforce_default_ordering=enforce_default_ordering, (12)
 default_encountered = False (12)
 type_var_tuple_encountered = False (12)
 parameters = [] (12)
 for t in args: (125)
 if isinstance(t, type): (113)
 elif isinstance(t, tuple): (113)
 elif hasattr(t, '__typing_subst__'): (113)
 if _is_unpacked_typevartuple(t): (113)
 return ((not isinstance(x, type)) and (226)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (113)
 for x in getattr(t, '__parameters__', ()): (113)
 if attr in {'__name__', '__qualname__'}: (154)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (154)
 raise AttributeError(attr) (154)
 return tuple(parameters) (12)
 if not name: (12)
 self.__module__ = origin.__module__ (12)
 return Union[self, right] (11)
 return hash(frozenset(self.__args__)) (11)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (132)
 return ((p, type(p)) for p in parameters) (1068)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (88)
 return NotImplemented (88)
 if not isinstance(other, _LiteralGenericAlias): (88)
 return NotImplemented (88)

 | type[np.signedinteger[Any]] (1)
 | np.dtype[np.signedinteger[Any]] (1)
 | _SupportsDType[np.dtype[np.signedinteger[Any]]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _Int8Codes (1)
 | _Int16Codes (1)
 | _Int32Codes (1)
 | _Int64Codes (1)
 | _ByteCodes (1)
 | _ShortCodes (1)
 | _IntCCodes (1)
 | _LongCodes (1)
 | _LongLongCodes (1)
 | _IntPCodes (1)
 | _IntCodes (1)
 _DTypeLikeInt: TypeAlias = ( (1)
 type[float] (11)
typing.py (8) return Union[left, self] (1)
 try: (8)
 return _caches[func](*args, **kwds) (8)
 return hash((self.__origin__, self.__args__)) (16)
 return self._getitem(self, parameters) (8)
 if parameters == (): (8)
 if not isinstance(parameters, tuple): (8)
 msg = "Union[arg, ...]: each arg must be a type." (8)
 parameters = tuple(_type_check(p, msg) for p in parameters) (32)
 invalid_generic_forms = (Generic, Protocol) (16)
 if not allow_special_forms: (16)
 invalid_generic_forms += (ClassVar,) (16)
 if is_argument: (16)
 invalid_generic_forms += (Final,) (16)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (16)
 if arg is None: (16)
 if isinstance(arg, str): (16)
 return arg (16)
 if (isinstance(arg, _GenericAlias) and (16)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (16)
 if allow_special_forms and arg in (ClassVar, Final): (16)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (16)
 if type(arg) is tuple: (16)
 return arg (16)
 arg.__origin__ in invalid_generic_forms): (15)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (8)
 params = [] (8)
 for p in parameters: (24)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (16)
 params.extend(p.__args__) (8)
 params.append(p) (8)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (8)
 try: (8)
 return dict.fromkeys(params) (8)
 if len(parameters) == 1: (8)
 if len(parameters) == 2 and type(None) in parameters: (8)
 return _UnionGenericAlias(self, parameters) (8)
 super().__init__(origin, inst=inst, name=name) (8)
 self._inst = inst (8)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (56)
 return attr.startswith('__') and attr.endswith('__') (128)
 super().__setattr__(attr, val) (56)
 self._name = name (8)
 self.__origin__ = origin (8)
 self.__slots__ = None  # This is not documented. (8)
 if not isinstance(args, tuple): (8)
 self.__args__ = tuple(... if a is _TypingEllipsis else (144)
 a for a in args) (136)
 enforce_default_ordering = origin in (Generic, Protocol) (8)
 self.__parameters__ = _collect_type_parameters( (16)
 args, (8)
 enforce_default_ordering=enforce_default_ordering, (8)
 default_encountered = False (8)
 type_var_tuple_encountered = False (8)
 parameters = [] (8)
 for t in args: (68)
 if isinstance(t, type): (60)
 elif isinstance(t, tuple): (60)
 elif hasattr(t, '__typing_subst__'): (60)
 if _is_unpacked_typevartuple(t): (60)
 return ((not isinstance(x, type)) and (120)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (60)
 for x in getattr(t, '__parameters__', ()): (60)
 if attr in {'__name__', '__qualname__'}: (72)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (72)
 raise AttributeError(attr) (72)
 return tuple(parameters) (8)
 if not name: (8)
 self.__module__ = origin.__module__ (8)
 return Union[self, right] (7)
 return hash(frozenset(self.__args__)) (7)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (56)
 return ((p, type(p)) for p in parameters) (452)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (56)
 return NotImplemented (56)
 if not isinstance(other, _LiteralGenericAlias): (56)
 return NotImplemented (56)

 | type[np.floating[Any]] (1)
 | np.dtype[np.floating[Any]] (1)
 | _SupportsDType[np.dtype[np.floating[Any]]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _Float16Codes (1)
 | _Float32Codes (1)
 | _Float64Codes (1)
 | _HalfCodes (1)
 | _SingleCodes (1)
 | _DoubleCodes (1)
 | _LongDoubleCodes (1)
 _DTypeLikeFloat: TypeAlias = ( (1)
 type[complex] (9)
typing.py (6) return Union[left, self] (1)
 try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash((self.__origin__, self.__args__)) (12)
 return self._getitem(self, parameters) (6)
 if parameters == (): (6)
 if not isinstance(parameters, tuple): (6)
 msg = "Union[arg, ...]: each arg must be a type." (6)
 parameters = tuple(_type_check(p, msg) for p in parameters) (24)
 invalid_generic_forms = (Generic, Protocol) (12)
 if not allow_special_forms: (12)
 invalid_generic_forms += (ClassVar,) (12)
 if is_argument: (12)
 invalid_generic_forms += (Final,) (12)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (12)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 if (isinstance(arg, _GenericAlias) and (12)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (12)
 if allow_special_forms and arg in (ClassVar, Final): (12)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (12)
 if type(arg) is tuple: (12)
 return arg (12)
 arg.__origin__ in invalid_generic_forms): (11)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (6)
 params = [] (6)
 for p in parameters: (18)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (12)
 params.extend(p.__args__) (6)
 params.append(p) (6)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (6)
 try: (6)
 return dict.fromkeys(params) (6)
 if len(parameters) == 1: (6)
 if len(parameters) == 2 and type(None) in parameters: (6)
 return _UnionGenericAlias(self, parameters) (6)
 super().__init__(origin, inst=inst, name=name) (6)
 self._inst = inst (6)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (42)
 return attr.startswith('__') and attr.endswith('__') (84)
 super().__setattr__(attr, val) (42)
 self._name = name (6)
 self.__origin__ = origin (6)
 self.__slots__ = None  # This is not documented. (6)
 if not isinstance(args, tuple): (6)
 self.__args__ = tuple(... if a is _TypingEllipsis else (96)
 a for a in args) (90)
 enforce_default_ordering = origin in (Generic, Protocol) (6)
 self.__parameters__ = _collect_type_parameters( (12)
 args, (6)
 enforce_default_ordering=enforce_default_ordering, (6)
 default_encountered = False (6)
 type_var_tuple_encountered = False (6)
 parameters = [] (6)
 for t in args: (45)
 if isinstance(t, type): (39)
 elif isinstance(t, tuple): (39)
 elif hasattr(t, '__typing_subst__'): (39)
 if _is_unpacked_typevartuple(t): (39)
 return ((not isinstance(x, type)) and (78)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (39)
 for x in getattr(t, '__parameters__', ()): (39)
 if attr in {'__name__', '__qualname__'}: (42)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (42)
 raise AttributeError(attr) (42)
 return tuple(parameters) (6)
 if not name: (6)
 self.__module__ = origin.__module__ (6)
 return Union[self, right] (5)
 return hash(frozenset(self.__args__)) (5)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (30)
 return ((p, type(p)) for p in parameters) (244)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (40)
 return NotImplemented (40)
 if not isinstance(other, _LiteralGenericAlias): (40)
 return NotImplemented (40)

 | type[np.complexfloating[Any]] (1)
 | np.dtype[np.complexfloating[Any]] (1)
 | _SupportsDType[np.dtype[np.complexfloating[Any]]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _Complex64Codes (1)
 | _Complex128Codes (1)
 | _CSingleCodes (1)
 | _CDoubleCodes (1)
 | _CLongDoubleCodes (1)
 _DTypeLikeComplex: TypeAlias = ( (1)
 type[np.timedelta64] (4)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (20)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (9)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (294)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | np.dtype[np.timedelta64] (1)
 | _SupportsDType[np.dtype[np.timedelta64]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _TD64Codes (1)
 _DTypeLikeDT64: TypeAlias = ( (1)
 type[np.datetime64] (4)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (20)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (9)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (7)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (294)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | np.dtype[np.datetime64] (1)
 | _SupportsDType[np.dtype[np.datetime64]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _DT64Codes (1)
 _DTypeLikeTD64: TypeAlias = ( (1)
 type[str] (5)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (24)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (11)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (9)
 elif hasattr(t, '__typing_subst__'): (9)
 if _is_unpacked_typevartuple(t): (9)
 return ((not isinstance(x, type)) and (18)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (9)
 for x in getattr(t, '__parameters__', ()): (9)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (20)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | type[np.str_] (1)
 | np.dtype[np.str_] (1)
 | _SupportsDType[np.dtype[np.str_]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _StrCodes (1)
 _DTypeLikeStr: TypeAlias = ( (1)
 type[bytes] (5)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (24)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (11)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (9)
 elif hasattr(t, '__typing_subst__'): (9)
 if _is_unpacked_typevartuple(t): (9)
 return ((not isinstance(x, type)) and (18)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (9)
 for x in getattr(t, '__parameters__', ()): (9)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (18)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | type[np.bytes_] (1)
 | np.dtype[np.bytes_] (1)
 | _SupportsDType[np.dtype[np.bytes_]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _BytesCodes (1)
 _DTypeLikeBytes: TypeAlias = ( (1)
 type[np.void] (5)
typing.py (3) return Union[left, self] (1)
 try: (3)
 return _caches[func](*args, **kwds) (3)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (3)
 if parameters == (): (3)
 if not isinstance(parameters, tuple): (3)
 msg = "Union[arg, ...]: each arg must be a type." (3)
 parameters = tuple(_type_check(p, msg) for p in parameters) (12)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if arg is None: (6)
 if isinstance(arg, str): (6)
 return arg (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 arg.__origin__ in invalid_generic_forms): (4)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (3)
 params = [] (3)
 for p in parameters: (9)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (6)
 params.extend(p.__args__) (4)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (3)
 try: (3)
 return dict.fromkeys(params) (3)
 if len(parameters) == 1: (3)
 if len(parameters) == 2 and type(None) in parameters: (3)
 return _UnionGenericAlias(self, parameters) (3)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 return attr.startswith('__') and attr.endswith('__') (31)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (41)
 a for a in args) (38)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (19)
 if isinstance(t, type): (16)
 elif isinstance(t, tuple): (15)
 elif hasattr(t, '__typing_subst__'): (15)
 if _is_unpacked_typevartuple(t): (15)
 return ((not isinstance(x, type)) and (30)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (15)
 for x in getattr(t, '__parameters__', ()): (15)
 if attr in {'__name__', '__qualname__'}: (10)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (10)
 raise AttributeError(attr) (10)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return Union[self, right] (2)
 return hash(frozenset(self.__args__)) (2)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (4)
 return ((p, type(p)) for p in parameters) (32)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (16)
 return NotImplemented (16)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)
 pass (1)

 | np.dtype[np.void] (1)
 | _SupportsDType[np.dtype[np.void]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _VoidCodes (1)
 | _VoidDTypeLike (1)
 _DTypeLikeVoid: TypeAlias = ( (1)
 type (4)
typing.py (2) return Union[left, self] (1)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (4)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (8)
 return NotImplemented (8)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (20)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (20)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (9)
 if isinstance(t, type): (7)
 pass (2)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 return ((not isinstance(x, type)) and (10)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (5)
 for x in getattr(t, '__parameters__', ()): (5)
 if attr in {'__name__', '__qualname__'}: (6)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (6)
 raise AttributeError(attr) (6)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash(frozenset(self.__args__)) (1)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (2)
 return ((p, type(p)) for p in parameters) (18)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)
 if not isinstance(other, _LiteralGenericAlias): (8)
 return NotImplemented (8)

 | np.dtype[np.object_] (1)
 | _SupportsDType[np.dtype[np.object_]] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _ObjectCodes (1)
 _DTypeLikeObject: TypeAlias = ( (1)
 _DTypeLikeBool (5)
typing.py (4) return Union[self, right] (4)
 try: (4)
 return _caches[func](*args, **kwds) (4)
 return hash(frozenset(self.__args__)) (8)
 return hash((self.__origin__, self.__args__)) (28)
 return hash(frozenset(_value_and_type_iter(self.__args__))) (182)
 return ((p, type(p)) for p in parameters) (1490)
 return self._getitem(self, parameters) (4)
 if parameters == (): (4)
 if not isinstance(parameters, tuple): (4)
 msg = "Union[arg, ...]: each arg must be a type." (4)
 parameters = tuple(_type_check(p, msg) for p in parameters) (16)
 invalid_generic_forms = (Generic, Protocol) (8)
 if not allow_special_forms: (8)
 invalid_generic_forms += (ClassVar,) (8)
 if is_argument: (8)
 invalid_generic_forms += (Final,) (8)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (8)
 if arg is None: (8)
 if isinstance(arg, str): (8)
 return arg (8)
 if (isinstance(arg, _GenericAlias) and (8)
 arg.__origin__ in invalid_generic_forms): (8)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (8)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (64)
 return NotImplemented (64)
 if allow_special_forms and arg in (ClassVar, Final): (8)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (8)
 if type(arg) is tuple: (8)
 return arg (8)
 parameters = _remove_dups_flatten(parameters) (4)
 params = [] (4)
 for p in parameters: (12)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (8)
 params.extend(p.__args__) (8)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (4)
 try: (4)
 return dict.fromkeys(params) (4)
 if len(parameters) == 1: (4)
 if len(parameters) == 2 and type(None) in parameters: (4)
 return _UnionGenericAlias(self, parameters) (4)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 return attr.startswith('__') and attr.endswith('__') (236)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (296)
 a for a in args) (292)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (146)
 if isinstance(t, type): (142)
 elif isinstance(t, tuple): (142)
 elif hasattr(t, '__typing_subst__'): (142)
 if _is_unpacked_typevartuple(t): (142)
 return ((not isinstance(x, type)) and (284)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (142)
 for x in getattr(t, '__parameters__', ()): (142)
 if attr in {'__name__', '__qualname__'}: (208)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (208)
 raise AttributeError(attr) (208)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)

 | _DTypeLikeUInt (1)
 | _DTypeLikeInt (1)
 | _DTypeLikeFloat (1)
 | _DTypeLikeComplex (1)
 _DTypeLikeComplex_co: TypeAlias = ( (1)

_array_like.py (3) from ._nested_sequence import _NestedSequence (1)
 from ._shape import _Shape (1)
 if TYPE_CHECKING: (1)
 from numpy._core.multiarray import StringDType (1)
 _T = TypeVar("_T") (1)
 _ScalarType = TypeVar("_ScalarType", bound=generic) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 _ScalarType_co = TypeVar("_ScalarType_co", bound=generic, covariant=True) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 _DType = TypeVar("_DType", bound=dtype[Any]) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 _DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) (1)
typing.py (1) invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 if allow_special_forms and arg in (ClassVar, Final): (1)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (1)
 if type(arg) is tuple: (1)
 return arg (1)

 NDArray: TypeAlias = ndarray[_Shape, dtype[_ScalarType_co]] (1)
 @runtime_checkable (3)
typing.py (1) if not issubclass(cls, Generic) or not getattr(cls, '_is_protocol', False): (1)
 cls._is_runtime_protocol = True (1)
 cls.__non_callable_proto_members__ = set() (1)
 for attr in cls.__protocol_attrs__: (2)
 try: (1)
 is_callable = callable(getattr(cls, attr, None)) (1)
 if not is_callable: (1)
 return cls (1)

 class _SupportsArray(Protocol[_DType_co]): (2)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 if not args: (1)
 if not all(_is_typevar_like(p) for p in args): (3)
 return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x) (1)
 if len(set(args)) != len(args): (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if t not in parameters: (1)
 if enforce_default_ordering: (1)
 if type_var_tuple_encountered and t.has_default(): (1)
 if t.has_default(): (1)
 elif default_encountered: (1)
 parameters.append(t) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)
 if isinstance(self.__origin__, _SpecialForm): (1)
 if self._name:  # generic version of an ABC or built-in class (1)
 if self.__origin__ is Generic: (1)
 return (self.__origin__,) (1)

 def __array__(self) -> ndarray[Any, _DType_co]: ... (1)
typing.py (1) if name == "Protocol" and bases == (Generic,): (1)
 elif Protocol in bases: (1)
 for base in bases: (2)
 base in {object, Generic} (1)
 or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) (1)
 issubclass(base, Generic) (1)
 and getattr(base, "_is_protocol", False) (1)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (1)
<frozen abc> (1) (1)

 super().__init_subclass__(*args, **kwargs) (1)
 super(Generic, cls).__init_subclass__(*args, **kwargs) (1)
 tvars = [] (1)
 if '__orig_bases__' in cls.__dict__: (1)
 error = Generic in cls.__orig_bases__ (1)
 if not isinstance(other, _GenericAlias): (1)
 return NotImplemented (1)
 if error: (1)
 if '__orig_bases__' in cls.__dict__: (1)
 tvars = _collect_type_parameters(cls.__orig_bases__) (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 return attr.startswith('__') and attr.endswith('__') (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 gvars = None (1)
 for base in cls.__orig_bases__: (2)
 if (isinstance(base, _GenericAlias) and (1)
 base.__origin__ is Generic): (1)
 if gvars is not None: (1)
 cls.__parameters__ = tuple(tvars) (1)
 if not cls.__dict__.get('_is_protocol', False): (1)
 cls._is_protocol = any(b is Protocol for b in cls.__bases__) (2)
 if '__subclasshook__' not in cls.__dict__: (1)
 cls.__subclasshook__ = _proto_hook (1)
 if cls._is_protocol and cls.__init__ is Protocol.__init__: (1)
 cls.__init__ = _no_init_or_replace_init (1)
<frozen abc> (1) (1)
 (1)

 super().__init__(*args, **kwargs) (1)
 if getattr(cls, "_is_protocol", False): (1)
 cls.__protocol_attrs__ = _get_protocol_attrs(cls) (1)
 attrs = set() (1)
 for base in cls.__mro__[:-1]:  # without object (4)
 if base.__name__ in {'Protocol', 'Generic'}: (3)
 annotations = getattr(base, '__annotations__', {}) (1)
 for attr in (*base.__dict__, *annotations): (16)
 if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: (15)
 attrs.add(attr) (1)
 continue (2)
 return attrs (1)

 @runtime_checkable (3)
typing.py (1) if not issubclass(cls, Generic) or not getattr(cls, '_is_protocol', False): (1)
 cls._is_runtime_protocol = True (1)
 cls.__non_callable_proto_members__ = set() (1)
 for attr in cls.__protocol_attrs__: (2)
 try: (1)
 is_callable = callable(getattr(cls, attr, None)) (1)
 if not is_callable: (1)
 return cls (1)

 class _SupportsArrayFunc(Protocol): (2)
 """A protocol class representing `~class.__array_function__`.""" (1)
 def __array_function__( (6)
typing.py (1) if name == "Protocol" and bases == (Generic,): (1)
 elif Protocol in bases: (1)
 for base in bases: (2)
 base in {object, Generic} (1)
 or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) (1)
 issubclass(base, Generic) (1)
 and getattr(base, "_is_protocol", False) (1)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (1)
<frozen abc> (1) (1)

 super().__init_subclass__(*args, **kwargs) (1)
 super(Generic, cls).__init_subclass__(*args, **kwargs) (1)
 tvars = [] (1)
 if '__orig_bases__' in cls.__dict__: (1)
 error = (Generic in cls.__bases__ and (1)
 if error: (1)
 if '__orig_bases__' in cls.__dict__: (1)
 cls.__parameters__ = tuple(tvars) (1)
 if not cls.__dict__.get('_is_protocol', False): (1)
 cls._is_protocol = any(b is Protocol for b in cls.__bases__) (2)
 if '__subclasshook__' not in cls.__dict__: (1)
 cls.__subclasshook__ = _proto_hook (1)
 if cls._is_protocol and cls.__init__ is Protocol.__init__: (1)
 cls.__init__ = _no_init_or_replace_init (1)
<frozen abc> (1) (1)
 (1)

 super().__init__(*args, **kwargs) (1)
 if getattr(cls, "_is_protocol", False): (1)
 cls.__protocol_attrs__ = _get_protocol_attrs(cls) (1)
 attrs = set() (1)
 for base in cls.__mro__[:-1]:  # without object (4)
 if base.__name__ in {'Protocol', 'Generic'}: (3)
 annotations = getattr(base, '__annotations__', {}) (1)
 for attr in (*base.__dict__, *annotations): (15)
 if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: (14)
 attrs.add(attr) (1)
 continue (2)
 return attrs (1)

 func: Callable[..., Any], (1)
 types: Collection[type[Any]], (1)
 args: tuple[Any, ...], (1)
 kwargs: dict[str, Any], (1)
 ) -> object: ... (1)
 _T (5)
typing.py (4) return Union[left, right] (1)
 try: (4)
 return _caches[func](*args, **kwds) (4)
 return self._getitem(self, parameters) (4)
 if parameters == (): (4)
 if not isinstance(parameters, tuple): (4)
 msg = "Union[arg, ...]: each arg must be a type." (4)
 parameters = tuple(_type_check(p, msg) for p in parameters) (16)
 invalid_generic_forms = (Generic, Protocol) (8)
 if not allow_special_forms: (8)
 invalid_generic_forms += (ClassVar,) (8)
 if is_argument: (8)
 invalid_generic_forms += (Final,) (8)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (8)
 if arg is None: (8)
 if isinstance(arg, str): (8)
 return arg (8)
 if (isinstance(arg, _GenericAlias) and (8)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (8)
 if allow_special_forms and arg in (ClassVar, Final): (8)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (8)
 if type(arg) is tuple: (8)
 return arg (8)
 parameters = _remove_dups_flatten(parameters) (4)
 params = [] (4)
 for p in parameters: (12)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (8)
 params.append(p) (5)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (4)
 try: (4)
 return dict.fromkeys(params) (4)
 if len(parameters) == 1: (4)
 if len(parameters) == 2 and type(None) in parameters: (4)
 return _UnionGenericAlias(self, parameters) (4)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 return attr.startswith('__') and attr.endswith('__') (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (40)
 a for a in args) (36)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (18)
 if isinstance(t, type): (14)
 elif isinstance(t, tuple): (14)
 elif hasattr(t, '__typing_subst__'): (14)
 if t not in parameters: (4)
 if enforce_default_ordering: (4)
 parameters.append(t) (4)
 if _is_unpacked_typevartuple(t): (10)
 return ((not isinstance(x, type)) and (20)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (10)
 for x in getattr(t, '__parameters__', ()): (20)
 if x not in parameters: (10)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return Union[self, right] (3)
 return hash(frozenset(self.__args__)) (3)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (24)
 return NotImplemented (24)
 params.extend(p.__args__) (3)

 | Sequence[_T] (1)
 | Sequence[Sequence[_T]] (1)
 | Sequence[Sequence[Sequence[_T]]] (1)
 | Sequence[Sequence[Sequence[Sequence[_T]]]] (1)
 _FiniteNestedSequence: TypeAlias = ( (1)
 _SupportsArray[dtype[_ScalarType]] (2)
typing.py (2) try: (2)
 return _caches[func](*args, **kwds) (2)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (18)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (12)
 a for a in args) (10)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (5)
 if isinstance(t, type): (3)
 elif isinstance(t, tuple): (3)
 elif hasattr(t, '__typing_subst__'): (3)
 if _is_unpacked_typevartuple(t): (3)
 return ((not isinstance(x, type)) and (6)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (3)
 for x in getattr(t, '__parameters__', ()): (6)
 if x not in parameters: (3)
 parameters.append(x) (2)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if (isinstance(arg, _GenericAlias) and (2)
 arg.__origin__ in invalid_generic_forms): (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if not isinstance(other, _GenericAlias): (18)
 return NotImplemented (18)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 if attr in {'__name__', '__qualname__'}: (4)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (4)
 raise AttributeError(attr) (4)

 | _NestedSequence[_SupportsArray[dtype[_ScalarType]]] (1)
typing.py (1) try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ArrayLike: TypeAlias = ( (1)
 _SupportsArray[_DType] (4)
typing.py (4) try: (4)
 return _caches[func](*args, **kwds) (4)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (7)
 if isinstance(arg, str): (7)
 return arg (7)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 return attr.startswith('__') and attr.endswith('__') (42)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (32)
 a for a in args) (28)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (14)
 if isinstance(t, type): (10)
 elif isinstance(t, tuple): (10)
 elif hasattr(t, '__typing_subst__'): (10)
 if t not in parameters: (3)
 if enforce_default_ordering: (3)
 parameters.append(t) (3)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return Union[self, right] (3)
 return hash((self.__origin__, self.__args__)) (20)
 return self._getitem(self, parameters) (3)
 if parameters == (): (3)
 if not isinstance(parameters, tuple): (3)
 msg = "Union[arg, ...]: each arg must be a type." (3)
 parameters = tuple(_type_check(p, msg) for p in parameters) (12)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if (isinstance(arg, _GenericAlias) and (6)
 arg.__origin__ in invalid_generic_forms): (5)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if not isinstance(other, _GenericAlias): (26)
 return NotImplemented (26)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 parameters = _remove_dups_flatten(parameters) (3)
 params = [] (3)
 for p in parameters: (9)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (6)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (3)
 try: (3)
 return dict.fromkeys(params) (3)
 if len(parameters) == 1: (3)
 if len(parameters) == 2 and type(None) in parameters: (3)
 return _UnionGenericAlias(self, parameters) (3)
 if attr in {'__name__', '__qualname__'}: (14)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (14)
 raise AttributeError(attr) (14)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (14)
 if x not in parameters: (7)
 parameters.append(x) (3)
 return hash(frozenset(self.__args__)) (2)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (16)
 return NotImplemented (16)
 params.extend(p.__args__) (2)

 | _NestedSequence[_SupportsArray[_DType]] (1)
typing.py (1) try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (2)
 if x not in parameters: (1)
 parameters.append(x) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 | _T (1)
 | _NestedSequence[_T] (1)
typing.py (1) try: (1)
 return _caches[func](*args, **kwds) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (7)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if t not in parameters: (1)
 if enforce_default_ordering: (1)
 parameters.append(t) (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _DualArrayLike: TypeAlias = ( (1)
 if sys.version_info >= (3, 12): (1)
 from collections.abc import Buffer as _Buffer (1)
 ArrayLike: TypeAlias = _Buffer | _DualArrayLike[ (2)
typing.py (1) try: (7)
 return _caches[func](*args, **kwds) (7)
 return hash(frozenset(self.__args__)) (2)
 return hash((self.__origin__, self.__args__)) (25)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (14)
 if isinstance(arg, str): (14)
 return arg (14)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (22)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (22)
 return attr.startswith('__') and attr.endswith('__') (57)
 raise AttributeError(attr) (22)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (9)
 if not allow_special_forms: (9)
 invalid_generic_forms += (ClassVar,) (9)
 if is_argument: (9)
 invalid_generic_forms += (Final,) (9)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (9)
 if (isinstance(arg, _GenericAlias) and (9)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (9)
 if allow_special_forms and arg in (ClassVar, Final): (9)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (9)
 if type(arg) is tuple: (9)
 return arg (9)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (32)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (16)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (5)
 self._inst = inst (5)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (35)
 super().__setattr__(attr, val) (35)
 self._name = name (5)
 self.__origin__ = origin (5)
 self.__slots__ = None  # This is not documented. (5)
 if not isinstance(args, tuple): (5)
 self.__args__ = tuple(... if a is _TypingEllipsis else (59)
 a for a in args) (54)
 enforce_default_ordering = origin in (Generic, Protocol) (5)
 self.__parameters__ = _collect_type_parameters( (10)
 args, (5)
 enforce_default_ordering=enforce_default_ordering, (5)
 default_encountered = False (5)
 type_var_tuple_encountered = False (5)
 parameters = [] (5)
 for t in args: (27)
 if isinstance(t, type): (22)
 elif isinstance(t, tuple): (9)
 elif hasattr(t, '__typing_subst__'): (9)
 if _is_unpacked_typevartuple(t): (9)
 for x in getattr(t, '__parameters__', ()): (9)
 return tuple(parameters) (5)
 if not name: (5)
 self.__module__ = origin.__module__ (5)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (10)
 arg.__origin__ in invalid_generic_forms): (4)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (8)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (6)
 params.append(p) (4)
 params.extend(p.__args__) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 pass (13)
 return Union[left, self] (1)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (8)
 return NotImplemented (8)

 dtype[Any], (2)
 bool | int | float | complex | str | bytes, (1)
 _ArrayLikeBool_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (24)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (12)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (26)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (11)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 pass (2)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 dtype[np.bool], (2)
 bool, (1)
 _ArrayLikeUInt_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (3)
 if not self.__parameters__: (3)
 if not isinstance(args, tuple): (3)
 args = _unpack_args(*(_type_convert(p) for p in args)) (10)
 if arg is None: (10)
 if isinstance(arg, str): (10)
 return arg (10)
 newargs = [] (3)
 for arg in args: (7)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (4)
 if subargs is not None and not (subargs and subargs[-1] is ...): (4)
 newargs.append(arg) (4)
 return newargs (3)
 new_args = self._determine_new_args(args) (3)
 params = self.__parameters__ (3)
 for param in params: (7)
 prepare = getattr(param, '__typing_prepare_subst__', None) (4)
 if prepare is not None: (4)
 args = prepare(self, args) (4)
 alen = len(args) (3)
 plen = len(params) (3)
 if alen != plen: (3)
 new_arg_by_param = dict(zip(params, args)) (3)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (3)
 new_args = [] (3)
 for old_arg in args: (9)
 if isinstance(old_arg, type): (6)
 substfunc = getattr(old_arg, '__typing_subst__', None) (6)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (37)
 raise AttributeError(attr) (16)
 if substfunc: (6)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (2)
 msg = "Parameters to generic types must be types." (2)
 arg = _type_check(arg, msg, is_argument=True) (2)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (2)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (2)
 return arg (2)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (6)
 elif _is_unpacked_typevartuple(old_arg): (6)
 return ((not isinstance(x, type)) and (22)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (11)
 elif isinstance(old_arg, tuple): (6)
 new_args.append(new_arg) (6)
 return new_args (3)
 r = self.copy_with(new_args) (3)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (2)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (21)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (9)
 if isinstance(t, type): (6)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return r (3)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (1)

 dtype[np.bool] | dtype[unsignedinteger[Any]], (2)
 bool, (1)
 _ArrayLikeInt_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (28)
 a for a in args) (24)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (12)
 if isinstance(t, type): (8)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (2)

 dtype[np.bool] | dtype[integer[Any]], (2)
 bool | int, (1)
 _ArrayLikeFloat_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (30)
 a for a in args) (26)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (13)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (3)

 dtype[np.bool] | dtype[integer[Any]] | dtype[floating[Any]], (2)
 bool | int | float, (1)
 _ArrayLikeComplex_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (32)
 a for a in args) (28)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (14)
 if isinstance(t, type): (10)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (4)

 dtype[np.bool] (4)
 | dtype[integer[Any]] (1)
 | dtype[floating[Any]] (1)
 | dtype[complexfloating[Any, Any]] (1)
 bool | int | float | complex, (1)
 ( (1)
 _ArrayLikeNumber_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (3)
 if not self.__parameters__: (3)
 if not isinstance(args, tuple): (3)
 args = _unpack_args(*(_type_convert(p) for p in args)) (10)
 if arg is None: (10)
 if isinstance(arg, str): (10)
 return arg (10)
 newargs = [] (3)
 for arg in args: (7)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (4)
 if subargs is not None and not (subargs and subargs[-1] is ...): (4)
 newargs.append(arg) (4)
 return newargs (3)
 new_args = self._determine_new_args(args) (3)
 params = self.__parameters__ (3)
 for param in params: (7)
 prepare = getattr(param, '__typing_prepare_subst__', None) (4)
 if prepare is not None: (4)
 args = prepare(self, args) (4)
 alen = len(args) (3)
 plen = len(params) (3)
 if alen != plen: (3)
 new_arg_by_param = dict(zip(params, args)) (3)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (3)
 new_args = [] (3)
 for old_arg in args: (9)
 if isinstance(old_arg, type): (6)
 substfunc = getattr(old_arg, '__typing_subst__', None) (6)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (37)
 raise AttributeError(attr) (16)
 if substfunc: (6)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (2)
 msg = "Parameters to generic types must be types." (2)
 arg = _type_check(arg, msg, is_argument=True) (2)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (2)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (2)
 return arg (2)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (6)
 elif _is_unpacked_typevartuple(old_arg): (6)
 return ((not isinstance(x, type)) and (22)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (11)
 elif isinstance(old_arg, tuple): (6)
 new_args.append(new_arg) (6)
 return new_args (3)
 r = self.copy_with(new_args) (3)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (2)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (27)
 a for a in args) (24)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (12)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return r (3)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (4)

 dtype[np.bool] | dtype[number[Any]], (2)
 bool | int | float | complex, (1)
 _ArrayLikeTD64_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (3)
 if not self.__parameters__: (3)
 if not isinstance(args, tuple): (3)
 args = _unpack_args(*(_type_convert(p) for p in args)) (10)
 if arg is None: (10)
 if isinstance(arg, str): (10)
 return arg (10)
 newargs = [] (3)
 for arg in args: (7)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (4)
 if subargs is not None and not (subargs and subargs[-1] is ...): (4)
 newargs.append(arg) (4)
 return newargs (3)
 new_args = self._determine_new_args(args) (3)
 params = self.__parameters__ (3)
 for param in params: (7)
 prepare = getattr(param, '__typing_prepare_subst__', None) (4)
 if prepare is not None: (4)
 args = prepare(self, args) (4)
 alen = len(args) (3)
 plen = len(params) (3)
 if alen != plen: (3)
 new_arg_by_param = dict(zip(params, args)) (3)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (3)
 new_args = [] (3)
 for old_arg in args: (9)
 if isinstance(old_arg, type): (6)
 substfunc = getattr(old_arg, '__typing_subst__', None) (6)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (37)
 raise AttributeError(attr) (16)
 if substfunc: (6)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (2)
 msg = "Parameters to generic types must be types." (2)
 arg = _type_check(arg, msg, is_argument=True) (2)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (2)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (2)
 return arg (2)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (6)
 elif _is_unpacked_typevartuple(old_arg): (6)
 return ((not isinstance(x, type)) and (22)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (11)
 elif isinstance(old_arg, tuple): (6)
 new_args.append(new_arg) (6)
 return new_args (3)
 r = self.copy_with(new_args) (3)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (2)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (23)
 a for a in args) (20)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (10)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return r (3)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (2)

 dtype[np.bool] | dtype[integer[Any]] | dtype[timedelta64], (2)
 bool | int, (1)
 _SupportsArray[dtype[datetime64]] (2)
typing.py (2) try: (2)
 return _caches[func](*args, **kwds) (2)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (18)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (12)
 a for a in args) (10)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (5)
 if isinstance(t, type): (3)
 elif isinstance(t, tuple): (3)
 elif hasattr(t, '__typing_subst__'): (3)
 if _is_unpacked_typevartuple(t): (3)
 return ((not isinstance(x, type)) and (6)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (3)
 for x in getattr(t, '__parameters__', ()): (3)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if (isinstance(arg, _GenericAlias) and (2)
 arg.__origin__ in invalid_generic_forms): (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if not isinstance(other, _GenericAlias): (18)
 return NotImplemented (18)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 if attr in {'__name__', '__qualname__'}: (4)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (4)
 raise AttributeError(attr) (4)

 | _NestedSequence[_SupportsArray[dtype[datetime64]]] (1)
typing.py (1) try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ArrayLikeDT64_co: TypeAlias = ( (1)
 _SupportsArray[dtype[object_]] (2)
typing.py (2) try: (2)
 return _caches[func](*args, **kwds) (2)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (18)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (12)
 a for a in args) (10)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (5)
 if isinstance(t, type): (3)
 elif isinstance(t, tuple): (3)
 elif hasattr(t, '__typing_subst__'): (3)
 if _is_unpacked_typevartuple(t): (3)
 return ((not isinstance(x, type)) and (6)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (3)
 for x in getattr(t, '__parameters__', ()): (3)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if (isinstance(arg, _GenericAlias) and (2)
 arg.__origin__ in invalid_generic_forms): (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if not isinstance(other, _GenericAlias): (18)
 return NotImplemented (18)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 if attr in {'__name__', '__qualname__'}: (4)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (4)
 raise AttributeError(attr) (4)

 | _NestedSequence[_SupportsArray[dtype[object_]]] (1)
typing.py (1) try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ArrayLikeObject_co: TypeAlias = ( (1)
 _SupportsArray[dtype[void]] (2)
typing.py (2) try: (2)
 return _caches[func](*args, **kwds) (2)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (18)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (12)
 a for a in args) (10)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (5)
 if isinstance(t, type): (3)
 elif isinstance(t, tuple): (3)
 elif hasattr(t, '__typing_subst__'): (3)
 if _is_unpacked_typevartuple(t): (3)
 return ((not isinstance(x, type)) and (6)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (3)
 for x in getattr(t, '__parameters__', ()): (3)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)
 return Union[self, right] (1)
 return hash((self.__origin__, self.__args__)) (6)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if (isinstance(arg, _GenericAlias) and (2)
 arg.__origin__ in invalid_generic_forms): (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if not isinstance(other, _GenericAlias): (18)
 return NotImplemented (18)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (3)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (2)
 params.append(p) (2)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 if attr in {'__name__', '__qualname__'}: (4)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (4)
 raise AttributeError(attr) (4)

 | _NestedSequence[_SupportsArray[dtype[void]]] (1)
typing.py (1) try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash((self.__origin__, self.__args__)) (1)
 if not isinstance(args, tuple): (1)
 args = (args,) (1)
 args = tuple(_type_convert(p) for p in args) (3)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 is_generic_or_protocol = cls in (Generic, Protocol) (1)
 if is_generic_or_protocol: (1)
 for param in cls.__parameters__: (2)
 prepare = getattr(param, '__typing_prepare_subst__', None) (1)
 if prepare is not None: (1)
 args = prepare(cls, args) (1)
 _check_generic_specialization(cls, args) (1)
 expected_len = len(cls.__parameters__) (1)
 if not expected_len: (1)
 actual_len = len(arguments) (1)
 if actual_len != expected_len: (1)
 new_args = [] (1)
 for param, new_arg in zip(cls.__parameters__, args): (2)
 if isinstance(param, TypeVarTuple): (1)
 new_args.append(new_arg) (1)
 args = tuple(new_args) (1)
 return _GenericAlias(cls, args) (1)
 super().__init__(origin, inst=inst, name=name) (1)
 self._inst = inst (1)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (7)
 return attr.startswith('__') and attr.endswith('__') (9)
 super().__setattr__(attr, val) (7)
 self._name = name (1)
 self.__origin__ = origin (1)
 self.__slots__ = None  # This is not documented. (1)
 if not isinstance(args, tuple): (1)
 self.__args__ = tuple(... if a is _TypingEllipsis else (5)
 a for a in args) (4)
 enforce_default_ordering = origin in (Generic, Protocol) (1)
 self.__parameters__ = _collect_type_parameters( (2)
 args, (1)
 enforce_default_ordering=enforce_default_ordering, (1)
 default_encountered = False (1)
 type_var_tuple_encountered = False (1)
 parameters = [] (1)
 for t in args: (2)
 if isinstance(t, type): (1)
 elif isinstance(t, tuple): (1)
 elif hasattr(t, '__typing_subst__'): (1)
 if attr in {'__name__', '__qualname__'}: (2)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (2)
 raise AttributeError(attr) (2)
 if _is_unpacked_typevartuple(t): (1)
 return ((not isinstance(x, type)) and (2)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (1)
 for x in getattr(t, '__parameters__', ()): (1)
 return tuple(parameters) (1)
 if not name: (1)
 self.__module__ = origin.__module__ (1)

 _ArrayLikeVoid_co: TypeAlias = ( (1)
 _ArrayLikeStr_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (24)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (12)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (26)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (11)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 pass (2)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 dtype[str_], (2)
 str, (1)
 _ArrayLikeBytes_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (24)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (12)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (26)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (11)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 pass (2)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 dtype[bytes_], (2)
 bytes, (1)
 _ArrayLikeString_co: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (3)
 if not self.__parameters__: (3)
 if not isinstance(args, tuple): (3)
 args = _unpack_args(*(_type_convert(p) for p in args)) (10)
 if arg is None: (10)
 if isinstance(arg, str): (10)
 return arg (10)
 newargs = [] (3)
 for arg in args: (7)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (4)
 if subargs is not None and not (subargs and subargs[-1] is ...): (4)
 newargs.append(arg) (4)
 return newargs (3)
 new_args = self._determine_new_args(args) (3)
 params = self.__parameters__ (3)
 for param in params: (7)
 prepare = getattr(param, '__typing_prepare_subst__', None) (4)
 if prepare is not None: (4)
 args = prepare(self, args) (4)
 alen = len(args) (3)
 plen = len(params) (3)
 if alen != plen: (3)
 new_arg_by_param = dict(zip(params, args)) (3)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (3)
 new_args = [] (3)
 for old_arg in args: (9)
 if isinstance(old_arg, type): (6)
 substfunc = getattr(old_arg, '__typing_subst__', None) (6)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (37)
 raise AttributeError(attr) (16)
 if substfunc: (6)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (2)
 msg = "Parameters to generic types must be types." (2)
 arg = _type_check(arg, msg, is_argument=True) (2)
 invalid_generic_forms = (Generic, Protocol) (6)
 if not allow_special_forms: (6)
 invalid_generic_forms += (ClassVar,) (6)
 if is_argument: (6)
 invalid_generic_forms += (Final,) (6)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (6)
 if (isinstance(arg, _GenericAlias) and (6)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (6)
 if allow_special_forms and arg in (ClassVar, Final): (6)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (6)
 if type(arg) is tuple: (6)
 return arg (6)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (2)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (2)
 return arg (2)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (6)
 elif _is_unpacked_typevartuple(old_arg): (6)
 return ((not isinstance(x, type)) and (20)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (10)
 elif isinstance(old_arg, tuple): (6)
 new_args.append(new_arg) (6)
 return new_args (3)
 r = self.copy_with(new_args) (3)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (2)
 super().__init__(origin, inst=inst, name=name) (3)
 self._inst = inst (3)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (21)
 super().__setattr__(attr, val) (21)
 self._name = name (3)
 self.__origin__ = origin (3)
 self.__slots__ = None  # This is not documented. (3)
 if not isinstance(args, tuple): (3)
 self.__args__ = tuple(... if a is _TypingEllipsis else (21)
 a for a in args) (18)
 enforce_default_ordering = origin in (Generic, Protocol) (3)
 self.__parameters__ = _collect_type_parameters( (6)
 args, (3)
 enforce_default_ordering=enforce_default_ordering, (3)
 default_encountered = False (3)
 type_var_tuple_encountered = False (3)
 parameters = [] (3)
 for t in args: (9)
 if isinstance(t, type): (6)
 pass (2)
 return tuple(parameters) (3)
 if not name: (3)
 self.__module__ = origin.__module__ (3)
 return r (3)
 elif isinstance(t, tuple): (4)
 elif hasattr(t, '__typing_subst__'): (4)
 if _is_unpacked_typevartuple(t): (4)
 for x in getattr(t, '__parameters__', ()): (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 StringDType, (2)
 str (1)
 _ArrayLikeStr_co | (3)
typing.py (2) return Union[self, right] (2)
 try: (2)
 return _caches[func](*args, **kwds) (2)
 return hash(frozenset(self.__args__)) (4)
 return hash((self.__origin__, self.__args__)) (40)
 return self._getitem(self, parameters) (2)
 if parameters == (): (2)
 if not isinstance(parameters, tuple): (2)
 msg = "Union[arg, ...]: each arg must be a type." (2)
 parameters = tuple(_type_check(p, msg) for p in parameters) (8)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 arg.__origin__ in invalid_generic_forms): (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if not isinstance(other, (_UnionGenericAlias, types.UnionType)): (32)
 return NotImplemented (32)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 parameters = _remove_dups_flatten(parameters) (2)
 params = [] (2)
 for p in parameters: (6)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.extend(p.__args__) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (2)
 try: (2)
 return dict.fromkeys(params) (2)
 if len(parameters) == 1: (2)
 if len(parameters) == 2 and type(None) in parameters: (2)
 return _UnionGenericAlias(self, parameters) (2)
 super().__init__(origin, inst=inst, name=name) (2)
 self._inst = inst (2)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (14)
 return attr.startswith('__') and attr.endswith('__') (42)
 super().__setattr__(attr, val) (14)
 self._name = name (2)
 self.__origin__ = origin (2)
 self.__slots__ = None  # This is not documented. (2)
 if not isinstance(args, tuple): (2)
 self.__args__ = tuple(... if a is _TypingEllipsis else (42)
 a for a in args) (40)
 enforce_default_ordering = origin in (Generic, Protocol) (2)
 self.__parameters__ = _collect_type_parameters( (4)
 args, (2)
 enforce_default_ordering=enforce_default_ordering, (2)
 default_encountered = False (2)
 type_var_tuple_encountered = False (2)
 parameters = [] (2)
 for t in args: (20)
 if isinstance(t, type): (18)
 elif isinstance(t, tuple): (14)
 elif hasattr(t, '__typing_subst__'): (14)
 if attr in {'__name__', '__qualname__'}: (28)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (28)
 raise AttributeError(attr) (28)
 if _is_unpacked_typevartuple(t): (14)
 return ((not isinstance(x, type)) and (28)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (14)
 for x in getattr(t, '__parameters__', ()): (14)
 pass (4)
 return tuple(parameters) (2)
 if not name: (2)
 self.__module__ = origin.__module__ (2)

 _ArrayLikeBytes_co | (1)
 _ArrayLikeString_co (1)
 _ArrayLikeAnyString_co: TypeAlias = ( (1)
 __Float64_co: TypeAlias = np.floating[_64Bit] | np.float32 | np.float16 | np.integer | np.bool (1)
 __Complex128_co: TypeAlias = np.number[_64Bit] | np.number[_32Bit] | np.float16 | np.integer | np.bool (1)
 _ArrayLikeFloat64_co: TypeAlias = _DualArrayLike[dtype[__Float64_co], float | int] (1)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (28)
 a for a in args) (24)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (12)
 if isinstance(t, type): (8)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (2)

 _ArrayLikeComplex128_co: TypeAlias = _DualArrayLike[dtype[__Complex128_co], complex | float | int] (1)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (26)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (13)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (30)
 a for a in args) (26)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (13)
 if isinstance(t, type): (9)
 elif isinstance(t, tuple): (6)
 elif hasattr(t, '__typing_subst__'): (6)
 if _is_unpacked_typevartuple(t): (6)
 for x in getattr(t, '__parameters__', ()): (6)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (3)
 params.extend(p.__args__) (1)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)
 pass (3)

 _ArrayLikeInt: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (7)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (7)
 if type(arg) is tuple: (7)
 return arg (7)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (24)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (12)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (26)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (11)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (5)
 elif hasattr(t, '__typing_subst__'): (5)
 if _is_unpacked_typevartuple(t): (5)
 for x in getattr(t, '__parameters__', ()): (5)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 pass (2)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 dtype[integer[Any]], (2)
 int, (1)
 if sys.version_info >= (3, 11): (1)
 from typing import Never as _UnknownType (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 _ArrayLikeUnknown: TypeAlias = _DualArrayLike[ (2)
typing.py (1) try: (6)
 return _caches[func](*args, **kwds) (6)
 return hash(frozenset(self.__args__)) (1)
 return hash((self.__origin__, self.__args__)) (17)
 if self.__origin__ in (Generic, Protocol): (4)
 if not self.__parameters__: (4)
 if not isinstance(args, tuple): (4)
 args = _unpack_args(*(_type_convert(p) for p in args)) (13)
 if arg is None: (12)
 if isinstance(arg, str): (12)
 return arg (12)
 newargs = [] (4)
 for arg in args: (9)
 subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) (5)
 if subargs is not None and not (subargs and subargs[-1] is ...): (5)
 newargs.append(arg) (5)
 if item in {'__name__', '__qualname__'}: (10)
 raise AttributeError(item) (10)
 return newargs (4)
 new_args = self._determine_new_args(args) (4)
 params = self.__parameters__ (4)
 for param in params: (9)
 prepare = getattr(param, '__typing_prepare_subst__', None) (5)
 if prepare is not None: (5)
 args = prepare(self, args) (5)
 alen = len(args) (4)
 plen = len(params) (4)
 if alen != plen: (4)
 new_arg_by_param = dict(zip(params, args)) (4)
 return tuple(self._make_substitution(self.__args__, new_arg_by_param)) (4)
 new_args = [] (4)
 for old_arg in args: (11)
 if isinstance(old_arg, type): (7)
 substfunc = getattr(old_arg, '__typing_subst__', None) (7)
 if attr in {'__name__', '__qualname__'}: (16)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (16)
 return attr.startswith('__') and attr.endswith('__') (44)
 raise AttributeError(attr) (16)
 if substfunc: (7)
 subparams = getattr(old_arg, '__parameters__', ()) (4)
 if not subparams: (4)
 subargs = [] (4)
 for x in subparams: (8)
 if isinstance(x, TypeVarTuple): (4)
 subargs.append(new_arg_by_param[x]) (4)
 new_arg = old_arg[tuple(subargs)] (4)
 new_arg = substfunc(new_arg_by_param[old_arg]) (3)
 msg = "Parameters to generic types must be types." (3)
 arg = _type_check(arg, msg, is_argument=True) (3)
 invalid_generic_forms = (Generic, Protocol) (7)
 if not allow_special_forms: (7)
 invalid_generic_forms += (ClassVar,) (7)
 if is_argument: (7)
 invalid_generic_forms += (Final,) (7)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (7)
 if (isinstance(arg, _GenericAlias) and (7)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (7)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (3)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (3)
 return arg (3)
 if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): (7)
 elif _is_unpacked_typevartuple(old_arg): (7)
 return ((not isinstance(x, type)) and (28)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (14)
 elif isinstance(old_arg, tuple): (7)
 new_args.append(new_arg) (7)
 return new_args (4)
 r = self.copy_with(new_args) (4)
 return self.__class__(self.__origin__, args, name=self._name, inst=self._inst) (3)
 super().__init__(origin, inst=inst, name=name) (4)
 self._inst = inst (4)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (28)
 super().__setattr__(attr, val) (28)
 self._name = name (4)
 self.__origin__ = origin (4)
 self.__slots__ = None  # This is not documented. (4)
 if not isinstance(args, tuple): (4)
 self.__args__ = tuple(... if a is _TypingEllipsis else (26)
 a for a in args) (22)
 enforce_default_ordering = origin in (Generic, Protocol) (4)
 self.__parameters__ = _collect_type_parameters( (8)
 args, (4)
 enforce_default_ordering=enforce_default_ordering, (4)
 default_encountered = False (4)
 type_var_tuple_encountered = False (4)
 parameters = [] (4)
 for t in args: (11)
 if isinstance(t, type): (7)
 elif isinstance(t, tuple): (7)
 elif hasattr(t, '__typing_subst__'): (7)
 if _is_unpacked_typevartuple(t): (7)
 for x in getattr(t, '__parameters__', ()): (7)
 return tuple(parameters) (4)
 if not name: (4)
 self.__module__ = origin.__module__ (4)
 return r (4)
 return arg (3)
 return Union[params] (1)
 return self._getitem(self, parameters) (1)
 if parameters == (): (1)
 if not isinstance(parameters, tuple): (1)
 msg = "Union[arg, ...]: each arg must be a type." (1)
 parameters = tuple(_type_check(p, msg) for p in parameters) (6)
 arg.__origin__ in invalid_generic_forms): (3)
 if not isinstance(other, _GenericAlias): (24)
 return NotImplemented (24)
 parameters = _remove_dups_flatten(parameters) (1)
 params = [] (1)
 for p in parameters: (5)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (4)
 params.append(p) (4)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (1)
 try: (1)
 return dict.fromkeys(params) (1)
 if len(parameters) == 1: (1)
 if len(parameters) == 2 and type(None) in parameters: (1)
 return _UnionGenericAlias(self, parameters) (1)

 dtype[_UnknownType], (2)
 _UnknownType, (1)

 (100)
 (100)
 (100)
 (100)
 (100)
 (100)
 (85)
 (100)
 (85)
 (85)
 (85)
 (100)
 (102)
 (376)
 (752)
dtypes.py (1) from numpy import dtypes (1)

overrides.py (1) ARRAY_FUNCTIONS = set() (1)
 """like : array_like, optional (1)
 array_function_like_doc = ( (1)
 def get_array_function_like_doc(public_api, docstring_template=""): (1)
 def finalize_array_function_like(public_api): (1)
 add_docstring( (2)
 _ArrayFunctionDispatcher, (1)
 """ (1)
 add_docstring( (2)
 _get_implementing_args, (1)
 """ (1)
 ArgSpec = collections.namedtuple('ArgSpec', 'args varargs keywords defaults') (1)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = field_names.replace(',', ' ').split() (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (6)
 if type(name) is not str: (5)
 if not name.isidentifier(): (5)
 if _iskeyword(name): (5)
 seen = set() (1)
 for name in field_names: (5)
 if name.startswith('_') and not rename: (4)
 if name in seen: (4)
 seen.add(name) (4)
 field_defaults = {} (1)
 if defaults is not None: (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (6)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (5)
 doc = _sys.intern(f'Alias for field number {index}') (4)
 class_namespace[name] = _tuplegetter(index, doc) (4)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 try: (1)
 module = _sys._getframemodulename(1) or '__main__' (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 def verify_matching_signatures(implementation, dispatcher): (1)
 def array_function_dispatch(dispatcher=None, module=None, verify=True, (2)
 docs_from_dispatcher=False): (1)
 implementation, module=None, verify=True, docs_from_dispatcher=True): (1)
 def array_function_from_dispatcher( (1)

umath.py (1) from . import _multiarray_umath (1)

_type_aliases.py (1) from numpy._core.multiarray import typeinfo, dtype (1)
 sctypeDict = {} (1)
 allTypes = {} (1)
 c_names_dict = {} (1)
 _abstract_type_names = { (1)
 for _abstract_type_name in _abstract_type_names: (11)
 allTypes[_abstract_type_name] = getattr(ma, _abstract_type_name) (10)
 for k, v in typeinfo.items(): (59)
 if k.startswith("NPY_") and v not in c_names_dict: (58)
 concrete_type = v.type (34)
 allTypes[k] = concrete_type (34)
 sctypeDict[k] = concrete_type (34)
 c_names_dict[k[4:]] = v (24)
 "double": "float64", (1)
 "cdouble": "complex128", (1)
 "single": "float32", (1)
 "csingle": "complex64", (1)
 "half": "float16", (1)
 "bool_": "bool", (1)
 "int_": "intp", (1)
 "uint": "uintp", (1)
 _aliases = { (1)
 for k, v in _aliases.items(): (9)
 sctypeDict[k] = allTypes[v] (8)
 allTypes[k] = allTypes[v] (8)
 "float": "float64", (1)
 "complex": "complex128", (1)
 "object": "object_", (1)
 "bytes": "bytes_", (1)
 "a": "bytes_", (1)
 "int": "int_", (1)
 "str": "str_", (1)
 "unicode": "str_", (1)
 _extra_aliases = { (1)
 for k, v in _extra_aliases.items(): (9)
 sctypeDict[k] = allTypes[v] (8)
 for is_complex, full_name in [(False, "longdouble"), (True, "clongdouble")]: (3)
 longdouble_type: type = allTypes[full_name] (2)
 bits: int = dtype(longdouble_type).itemsize * 8 (2)
 base_name: str = "complex" if is_complex else "float" (2)
 extended_prec_name: str = f"{base_name}{bits}" (2)
 if extended_prec_name not in allTypes: (2)
 sctypes = {"int": set(), "uint": set(), "float": set(), (2)
 "complex": set(), "others": set()} (1)
 for type_info in typeinfo.values(): (59)
 if type_info.kind in ["M", "m"]:  # exclude timedelta and datetime (58)
 concrete_type = type_info.type (54)
 ("int", ma.signedinteger), ("uint", ma.unsignedinteger), (54)
 ("float", ma.floating), ("complex", ma.complexfloating), (54)
 ("others", ma.generic) (54)
 for type_group, abstract_type in [ (143)
 if issubclass(concrete_type, abstract_type): (143)
 sctypes[type_group].add(concrete_type) (54)
 break (54)
 continue (4)
 for sctype_key in sctypes.keys(): (6)
 sctype_list = list(sctypes[sctype_key]) (5)
 sctype_list.sort(key=lambda x: dtype(x).itemsize) (27)
 sctypes[sctype_key] = sctype_list (5)

_dtype.py (1) 'u': 'uint', (1)
 'i': 'int', (1)
 'c': 'complex', (1)
 'f': 'float', (1)
 'b': 'bool', (1)
 'V': 'void', (1)
 'O': 'object', (1)
 'M': 'datetime', (1)
 'm': 'timedelta', (1)
 'S': 'bytes', (1)
 'U': 'str', (1)
 _kind_to_stem = { (1)
 def _kind_name(dtype): (1)
 def __str__(dtype): (1)
 def __repr__(dtype): (1)
 def _unpack_field(dtype, offset, title=None): (1)
 def _isunsized(dtype): (1)
 def _construction_repr(dtype, include_align=False, short=False): (1)
 def _scalar_str(dtype, short): (1)
 def _byte_order_str(dtype): (1)
 def _datetime_metadata_str(dtype): (1)
 def _struct_dict_str(dtype, includealignedflag): (1)
 def _aligned_offset(offset, alignment): (1)
 def _is_packed(dtype): (1)
 def _struct_list_str(dtype): (1)
 def _struct_str(dtype, include_align): (1)
 def _subarray_str(dtype): (1)
 def _name_includes_bit_suffix(dtype): (1)
 def _name_get(dtype): (1)

numeric.py (1) from . import multiarray (1)

shape_base.py (1) from . import overrides (1)

fromnumeric.py (1) from .._utils import set_module (1)

_methods.py (1) from numpy._core import multiarray as mu (1)

arrayprint.py (3) from . import numerictypes as _nt (1)
 from .numerictypes import (longlong, intc, int_, float64, complex128, (1)
 if (format_options.get()['legacy'] <= 113 and (18)
 if a.shape == (): (18)
 return _guarded_repr_or_str(np.ndarray.__getitem__(a, ())) (18)
 key = id(self), get_ident() (18)
 if key in repr_running: (18)
 repr_running.add(key) (18)
 try: (18)
 return f(self, *args, **kwargs) (18)
 if isinstance(v, bytes): (18)
 return str(v) (18)
 repr_running.discard(key) (18)
getlimits.py (18) self._str_epsneg = self._float_to_str(self.epsneg) (3)
 return self.params['fmt'] % array(_fr0(value)[0], self.ftype) (17)
 if a.ndim == 0: (17)
 a = a.copy() (17)
 a.shape = (1,) (17)
 return a (17)
 self._str_xmin = self._float_to_str(self.xmin) (3)
 self._str_xmax = self._float_to_str(self.xmax) (3)
 self._str_resolution = self._float_to_str(self.resolution) (3)
 self._str_smallest_normal = self._float_to_str(self.xmin) (3)
 _register_type(float128_ma, (2)
 b'\x9a\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xfb\xbf') (1)
 _KNOWN_TYPES[bytepat] = machar (4)
 _float_ma[128] = float128_ma (1)
 epsneg_f80 = exp2(ld(-64)) (1)
 tiny_f80 = exp2(ld(-16382)) (1)
 with numeric.errstate(all='ignore'): (2)
_ufunc_config.py (2) self._token = None (1)
 self._call = call (1)
 self._all = all (1)
 self._divide = divide (1)
 self._over = over (1)
 self._under = under (1)
 self._invalid = invalid (1)
 if self._token is not None: (1)
 if self._call is _Unspecified: (1)
 extobj = _make_extobj( (2)
 all=self._all, divide=self._divide, over=self._over, (1)
 under=self._under, invalid=self._invalid) (1)
 self._token = _extobj_contextvar.set(extobj) (1)
 _extobj_contextvar.reset(self._token) (1)

 huge_f80 = (ld(1) - epsneg_f80) / tiny_f80 * ld(4) (1)
 float80_ma = MachArLike(ld, (2)
 machep=-63, (1)
 negep=-64, (1)
 minexp=-16382, (1)
 maxexp=16384, (1)
 it=63, (1)
 iexp=15, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=exp2(ld(-63)), (1)
 epsneg=epsneg_f80, (1)
 huge=huge_f80, (1)
 tiny=tiny_f80) (1)
 self.params = _MACHAR_PARAMS[ftype] (2)
 self.ftype = ftype (2)
 self.title = self.params['title'] (2)
 if not smallest_subnormal: (2)
 self._smallest_subnormal = nextafter( (2)
 self.ftype(0), self.ftype(1), dtype=self.ftype) (1)
 self.epsilon = self.eps = self._float_to_float(eps) (2)
 return _fr1(self._float_conv(value)) (12)
 return array([value], self.ftype) (14)
 if a.size == 1: (12)
 a = a.copy() (12)
 a.shape = () (12)
 return a (12)
 self.epsneg = self._float_to_float(epsneg) (2)
 self.xmax = self.huge = self._float_to_float(huge) (2)
 self.xmin = self._float_to_float(tiny) (2)
 self.smallest_normal = self.tiny = self._float_to_float(tiny) (2)
 self.ibeta = self.params['itype'](ibeta) (2)
 self.__dict__.update(kwargs) (2)
 self.precision = int(-log10(self.eps)) (2)
 self.resolution = self._float_to_float( (4)
 self._float_conv(10) ** (-self.precision)) (2)
 self._str_eps = self._float_to_str(self.eps) (2)
 _register_type(float80_ma, b'\xcd\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xfb\xbf') (1)
 _float_ma[80] = float80_ma (1)
 huge_dd = nextafter(ld(inf), ld(0), dtype=ld) (1)
 smallest_normal_dd = nan (1)
 smallest_subnormal_dd = ld(nextafter(0., 1.)) (1)
 float_dd_ma = MachArLike(ld, (2)
 machep=-105, (1)
 negep=-106, (1)
 minexp=-1022, (1)
 maxexp=1024, (1)
 it=105, (1)
 iexp=11, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=exp2(ld(-105)), (1)
 epsneg=exp2(ld(-106)), (1)
 huge=huge_dd, (1)
 tiny=smallest_normal_dd, (1)
 smallest_subnormal=smallest_subnormal_dd) (1)
 self._smallest_subnormal = smallest_subnormal (1)
 _register_type(float_dd_ma, (2)
 b'\x9a\x99\x99\x99\x99\x99Y<\x9a\x99\x99\x99\x99\x99\xb9\xbf') (1)
 _register_type(float_dd_ma, (2)
 b'\x9a\x99\x99\x99\x99\x99\xb9\xbf\x9a\x99\x99\x99\x99\x99Y<') (1)
 _float_ma['dd'] = float_dd_ma (1)
__init__.py (1) __all__ = list( (2)
 __numpy_submodules__ | (18)
 set(_core.__all__) | (1)
 set(_mat.__all__) | (1)
 set(lib._histograms_impl.__all__) | (1)
 set(lib._nanfunctions_impl.__all__) | (1)
 set(lib._function_base_impl.__all__) | (1)
 set(lib._twodim_base_impl.__all__) | (1)
 set(lib._shape_base_impl.__all__) | (1)
 set(lib._type_check_impl.__all__) | (1)
 set(lib._arraysetops_impl.__all__) | (1)
 set(lib._ufunclike_impl.__all__) | (1)
 set(lib._arraypad_impl.__all__) | (1)
 set(lib._utils_impl.__all__) | (1)
 set(lib._stride_tricks_impl.__all__) | (1)
 set(lib._polynomial_impl.__all__) | (1)
 set(lib._npyio_impl.__all__) | (1)
 set(lib._index_tricks_impl.__all__) | (1)
 {"emath", "show_config", "__version__", "__array_namespace_info__"} (1)
 warnings.filterwarnings("ignore", message="numpy.dtype size changed") (4)
warnings.py (1) if action not in {"error", "ignore", "always", "default", "module", "once"}: (1)
 if not isinstance(message, str): (1)
 if not isinstance(category, type) or not issubclass(category, Warning): (1)
 if not isinstance(module, str): (1)
 if not isinstance(lineno, int): (1)
 if lineno < 0: (1)
 if message or module: (1)
 import re (1)
 if message: (1)
 message = re.compile(message, re.I) (1)

 return _compile(pattern, flags) (3)
 if isinstance(flags, RegexFlag): (3)
 flags = flags.value (3)
enum.py (3) if instance is None: (3)
 if self.fget is not None: (3)
 return self.fget(instance) (3)
 return self._value_ (3)

 try: (3)
 except KeyError: (4)
warnings.py (1) if action not in {"error", "ignore", "always", "default", "module", "once"}: (1)
 if not isinstance(message, str): (1)
 if not isinstance(category, type) or not issubclass(category, Warning): (1)
 if not isinstance(module, str): (1)
 if not isinstance(lineno, int): (1)
 if lineno < 0: (1)
 if message or module: (1)
 import re (1)
 if message: (1)
 message = re.compile(message, re.I) (1)

 pass (4)
warnings.py (1) if action not in {"error", "ignore", "always", "default", "module", "once"}: (1)
 if not isinstance(message, str): (1)
 if not isinstance(category, type) or not issubclass(category, Warning): (1)
 if not isinstance(module, str): (1)
 if not isinstance(lineno, int): (1)
 if lineno < 0: (1)
 if message or module: (1)
 import re (1)
 if message: (1)
 message = re.compile(message, re.I) (1)

 key = (type(pattern), pattern, flags) (4)
 p = _cache.pop(key, None) (3)
 if p is None: (3)
 if isinstance(pattern, Pattern): (3)
 if not _compiler.isstring(pattern): (3)
_compiler.py (3) return isinstance(obj, (str, bytes)) (3)

 p = _compiler.compile(pattern, flags) (3)
_compiler.py (3) if isstring(p): (3)
 return isinstance(obj, (str, bytes)) (3)
 pattern = p (3)
 p = _parser.parse(p, flags) (3)
_parser.py (3) source = Tokenizer(str) (3)
 self.istext = isinstance(string, str) (3)
 self.string = string (3)
 if not self.istext: (3)
 self.decoded_string = string (3)
 self.index = 0 (3)
 self.next = None (3)
 self.__next() (3)
 index = self.index (77)
 try: (77)
 char = self.decoded_string[index] (77)
 if char == "\\": (74)
 self.index = index + 1 (74)
 self.next = char (74)
 if state is None: (3)
 state = State() (3)
 self.flags = 0 (3)
 self.groupdict = {} (3)
 self.groupwidths = [None]  # group 0 (3)
 self.lookbehindgroups = None (3)
 self.grouprefpos = {} (3)
 state.flags = flags (3)
 state.str = str (3)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (3)
 items = [] (3)
 itemsappend = items.append (3)
 sourcematch = source.match (3)
 start = source.tell() (3)
 return self.index - len(self.next or '') (3)
 while True: (3)
 itemsappend(_parse(source, state, verbose, nested + 1, (6)
 not nested and not items)) (3)
 subpattern = SubPattern(state) (3)
 self.state = state (3)
 if data is None: (3)
 data = [] (3)
 self.data = data (3)
 self.width = None (3)
 subpatternappend = subpattern.append (3)
 sourceget = source.get (3)
 sourcematch = source.match (3)
 _len = len (3)
 _ord = ord (3)
 while True: (77)
 this = source.next (77)
 if this is None: (77)
 if this in "|)": (74)
 sourceget() (74)
 this = self.next (74)
 self.__next() (74)
 return this (74)
 if verbose: (74)
 if this[0] == "\\": (74)
 elif this not in SPECIAL_CHARS: (74)
 subpatternappend((LITERAL, _ord(this))) (71)
 self.data.append(code) (74)
 elif this == "[": (3)
 elif this in REPEAT_CHARS: (3)
 elif this == ".": (3)
 subpatternappend((ANY, None)) (3)
 except IndexError: (3)
 self.next = None (3)
 return (3)
 break # end of pattern (3)
 for i in range(len(subpattern))[::-1]: (77)
 return len(self.data) (3)
 op, av = subpattern[i] (74)
 if isinstance(index, slice): (74)
 return self.data[index] (74)
 if op is SUBPATTERN: (74)
 return subpattern (3)
 if not sourcematch("|"): (3)
 if char == self.next: (3)
 return False (3)
 break (3)
 if len(items) == 1: (3)
 return items[0] (3)
 p.state.flags = fix_flags(str, p.state.flags) (3)
 if isinstance(src, str): (3)
 if flags & SRE_FLAG_LOCALE: (3)
 if not flags & SRE_FLAG_ASCII: (3)
 flags |= SRE_FLAG_UNICODE (3)
 return flags (3)
 if source.next is not None: (3)
 for g in p.state.grouprefpos: (3)
 if flags & SRE_FLAG_DEBUG: (3)
 return p (3)

 code = _code(p, flags) (3)
 flags = p.state.flags | flags (3)
 code = [] (3)
 _compile_info(code, p, flags) (3)
 lo, hi = pattern.getwidth() (3)
_parser.py (3) if self.width is not None: (3)
 lo = hi = 0 (3)
 for op, av in self.data: (77)
 if op is BRANCH: (74)
 elif op is ATOMIC_GROUP: (74)
 elif op is SUBPATTERN: (74)
 elif op in _REPEATCODES: (74)
 elif op in _UNITCODES: (74)
 lo = lo + 1 (74)
 hi = hi + 1 (74)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (3)
 return self.width (3)

 if hi > MAXCODE: (3)
 if lo == 0: (3)
 prefix = [] (3)
 prefix_skip = 0 (3)
 charset = [] # not used (3)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (3)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (3)
 prefix = [] (3)
 prefixappend = prefix.append (3)
 prefix_skip = None (3)
 iscased = _get_iscased(flags) (3)
 if not flags & SRE_FLAG_IGNORECASE: (6)
 elif flags & SRE_FLAG_UNICODE: (6)
 return _sre.unicode_iscased (6)
 for op, av in pattern.data: (3)
 if op is LITERAL: (3)
 if iscased and iscased(av): (3)
 break (3)
 return prefix, prefix_skip, False (3)
 if not prefix: (3)
 charset = _get_charset_prefix(pattern, flags) (3)
 while True: (3)
 if not pattern.data: (3)
 op, av = pattern.data[0] (3)
 if op is not SUBPATTERN: (3)
 break (3)
 iscased = _get_iscased(flags) (3)
 if op is LITERAL: (3)
 if iscased and iscased(av): (3)
 return None (3)
 emit = code.append (3)
 emit(INFO) (3)
 skip = len(code); emit(0) (3)
 mask = 0 (3)
 if prefix: (3)
 elif charset: (3)
 emit(mask) (3)
 if lo < MAXCODE: (3)
 emit(lo) (3)
 emit(hi) (3)
 if prefix: (3)
 elif charset: (3)
 code[skip] = len(code) - skip (3)
 _compile(code, p.data, flags) (3)
 emit = code.append (3)
 _len = len (3)
 LITERAL_CODES = _LITERAL_CODES (3)
 REPEATING_CODES = _REPEATING_CODES (3)
 SUCCESS_CODES = _SUCCESS_CODES (3)
 ASSERT_CODES = _ASSERT_CODES (3)
 iscased = None (3)
 tolower = None (3)
 fixes = None (3)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (3)
 if flags & SRE_FLAG_UNICODE: (3)
 iscased = _sre.unicode_iscased (3)
 tolower = _sre.unicode_tolower (3)
 fixes = _EXTRA_CASES (3)
 for op, av in pattern: (77)
 if op in LITERAL_CODES: (74)
 if not flags & SRE_FLAG_IGNORECASE: (71)
 elif flags & SRE_FLAG_LOCALE: (71)
 elif not iscased(av): (71)
 lo = tolower(av) (65)
 if not fixes:  # ascii (65)
 elif lo not in fixes: (65)
 emit(OP_UNICODE_IGNORE[op]) (59)
 emit(lo) (59)
 elif op is IN: (3)
 elif op is ANY: (3)
 if flags & SRE_FLAG_DOTALL: (3)
 emit(ANY) (3)
 emit(op) (6)
 emit(av) (6)
 emit(IN_UNI_IGNORE) (6)
 skip = _len(code); emit(0) (6)
 if op is NOT_LITERAL: (6)
 for k in (lo,) + fixes[lo]: (18)
 emit(LITERAL) (12)
 emit(k) (12)
 emit(FAILURE) (6)
 code[skip] = _len(code) - skip (6)
 code.append(SUCCESS) (3)
 return code (3)
 if flags & SRE_FLAG_DEBUG: (3)
 groupindex = p.state.groupdict (3)
 indexgroup = [None] * p.state.groups (3)
_parser.py (3) return len(self.groupwidths) (3)

 for k, i in groupindex.items(): (3)
 return _sre.compile( (6)
 pattern, flags | p.state.flags, code, (3)
 p.state.groups-1, (3)
_parser.py (3) return len(self.groupwidths) (3)

 groupindex, tuple(indexgroup) (3)

 if flags & DEBUG: (3)
enum.py (3) other_value = self._get_value(other) (3)
 if isinstance(flag, self.__class__): (9)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (6)
 return flag (6)
 if other_value is NotImplemented: (3)
 for flag in self, other: (9)
 if self._get_value(flag) is None: (6)
 return flag._value_ (3)
 value = self._value_ (3)
 return self.__class__(value & other_value) (3)
 if cls._member_map_: (3)
 if names is not _not_given: (3)
 return cls.__new__(cls, value) (3)
 if type(value) is cls: (3)
 try: (3)
 return cls._value2member_map_[value] (3)

 if len(_cache) >= _MAXCACHE: (3)
 _cache[key] = p (3)
 if len(_cache2) >= _MAXCACHE2: (3)
 _cache2[key] = p (3)
 return p (3)
warnings.py (3) if module: (3)
 module = None (3)
 _add_filter(action, message, category, module, lineno, append=append) (3)
 if not append: (3)
 try: (3)
 filters.remove(item) (3)
 except ValueError: (3)
 pass (3)
 filters.insert(0, item) (3)
 _filters_mutated() (3)

 def __dir__(): (1)
 from numpy._pytesttester import PytestTester (1)
 test = PytestTester(__name__) (1)
_pytesttester.py (1) self.module_name = module_name (1)
 self.__module__ = module_name (1)

 del PytestTester (1)
 def _sanity_check(): (1)
 _sanity_check() (1)
 try: (1)
 x = ones(2, dtype=float32) (1)
numeric.py (1) if like is not None: (1)
 a = empty(shape, dtype, order, device=device) (1)
 multiarray.copyto(a, 1, casting='unsafe') (1)
multiarray.py (1) return (dst, src, where) (1)

 return a (1)

 if not abs(x.dot(x) - float32(2.0)) < 1e-5: (1)
 del _sanity_check (1)
 def _mac_os_check(): (1)
 if sys.platform == "darwin": (1)
 del _mac_os_check (1)
 def hugepage_setup(): (1)
 _core.multiarray._set_madvise_hugepage(hugepage_setup()) (1)
 use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None) (1)
<frozen _collections_abc> (1) (1)
 (1)
<frozen os> (1) (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)

 (1)
 (1)

 if sys.platform == "linux" and use_hugepage is None: (1)
 elif use_hugepage is None: (1)
 use_hugepage = 1 (1)
 return use_hugepage (1)
 del hugepage_setup (1)
 _core.multiarray._multiarray_umath._reload_guard() (1)
 if (os.environ.get("NPY_PROMOTION_STATE", "weak") != "weak"): (1)
<frozen _collections_abc> (1) (1)
 (1)
<frozen os> (1) (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)

 (1)
 (1)

 def _pyinstaller_hooks_dir(): (1)
 del os, sys, warnings (1)



memmap.py (1) from .._utils import set_module (1)

function_base.py (1) from . import numeric as _nx (1)

_dtype_ctypes.py (1) def _from_ctypes_array(t): (1)
 def _from_ctypes_structure(t): (1)
 def _from_ctypes_scalar(t): (1)
 def _from_ctypes_union(t): (1)
 def dtype_from_ctypes_type(t): (1)

_npyio_impl.py (1) from . import format (1)

format.py (1) from numpy.lib._utils_impl import drop_metadata (1)

_utils_impl.py (1) __all__ = [ (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def show_runtime(): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def get_include(): (2)
 class _Deprecate: (2)
 """ (1)
 def __init__(self, old_name=None, new_name=None, message=None): (1)
 def __call__(self, func, *args, **kwargs): (1)
 def _get_indent(lines): (1)
 def deprecate(*args, **kwargs): (1)
 def deprecate_with_doc(msg): (1)
 def _split_line(name, arguments, width): (1)
 _namedict = None (1)
 _dictlist = None (1)
 def _makenamedict(module='numpy'): (1)
 def _info(obj, output=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def info(object=None, maxwidth=76, output=None, toplevel='numpy'): (2)
 def safe_eval(source): (1)
 def _median_nancheck(data, result, axis): (1)
 def _opt_info(): (1)
 def drop_metadata(dtype, /): (1)

_iotools.py (2) import numpy._core.numeric as nx (1)
 from numpy._utils import asbytes, asunicode (1)

_scimath_impl.py (2) import numpy._core.numerictypes as nt (1)
 from numpy._core.numeric import asarray, any (1)
 from numpy._core.overrides import array_function_dispatch, set_module (1)
 from numpy.lib._type_check_impl import isreal (1)

_type_check_impl.py (1) from numpy._core.numeric import asarray, asanyarray, isnan, zeros (1)
 from numpy._core import overrides, getlimits (1)

_ufunclike_impl.py (1) from numpy._core.overrides import array_function_dispatch (1)
 def _dispatcher(x, out=None): (1)
 @array_function_dispatch(_dispatcher, verify=False, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def fix(x, out=None): (2)
 @array_function_dispatch(_dispatcher, verify=False, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isposinf(x, out=None): (2)
 @array_function_dispatch(_dispatcher, verify=False, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isneginf(x, out=None): (2)

_stride_tricks_impl.py (1) from numpy._core.numeric import normalize_axis_tuple (1)
 from numpy._core.overrides import array_function_dispatch, set_module (1)
 __all__ = ['broadcast_to', 'broadcast_arrays', 'broadcast_shapes'] (1)
 class DummyArray: (2)
 """Dummy object that just exists to hang __array_interface__ dictionaries (1)
 def __init__(self, interface, base=None): (1)
 def _maybe_view_as_subclass(original_array, new_array): (1)
 @set_module("numpy.lib.stride_tricks") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def as_strided(x, shape=None, strides=None, subok=False, writeable=True): (2)
 def _sliding_window_view_dispatcher(x, window_shape, axis=None, *, (2)
 subok=None, writeable=None): (1)
 @array_function_dispatch( (3)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 _sliding_window_view_dispatcher, module="numpy.lib.stride_tricks" (1)
 def sliding_window_view(x, window_shape, axis=None, *, (3)
 subok=False, writeable=False): (1)
 def _broadcast_to(array, shape, subok, readonly): (1)
 def _broadcast_to_dispatcher(array, shape, subok=None): (1)
 @array_function_dispatch(_broadcast_to_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def broadcast_to(array, shape, subok=False): (2)
 def _broadcast_shape(*args): (1)
 _size0_dtype = np.dtype([]) (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def broadcast_shapes(*args): (2)
 def _broadcast_arrays_dispatcher(*args, subok=None): (1)
 @array_function_dispatch(_broadcast_arrays_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def broadcast_arrays(*args, subok=False): (2)

_index_tricks_impl.py (3) from .._utils import set_module (1)
 from numpy._core.numeric import ScalarType, array (1)
 from numpy._core.numerictypes import issubdtype (1)
 import numpy.matrixlib as matrixlib (1)
 from numpy._core.multiarray import ravel_multi_index, unravel_index (1)
 from numpy._core import overrides, linspace (1)

defmatrix.py (1) from numpy._core.numeric import concatenate, isscalar (1)
 from numpy.linalg import matrix_power (1)

typing.py (18) super(Generic, cls).__init_subclass__(*args, **kwargs) (12)
 tvars = [] (12)
 if '__orig_bases__' in cls.__dict__: (12)
 error = (Generic in cls.__bases__ and (8)
 cls.__name__ != 'Protocol' and (1)
 if error: (12)
 if '__orig_bases__' in cls.__dict__: (12)
 cls.__parameters__ = tuple(tvars) (12)
<frozen abc> (1) (1)
 (1)

 super().__init__(*args, **kwargs) (9)
 if getattr(cls, "_is_protocol", False): (9)
 cls.__protocol_attrs__ = _get_protocol_attrs(cls) (9)
 attrs = set() (9)
 for base in cls.__mro__[:-1]:  # without object (35)
 if base.__name__ in {'Protocol', 'Generic'}: (26)
 continue (18)
 return attrs (9)
 class _AnnotatedAlias(_NotIterable, _GenericAlias, _root=True): (2)
 """Runtime representation of an annotated type. (1)
 def __init__(self, origin, metadata): (1)
 def copy_with(self, params): (1)
 def __repr__(self): (1)
 def __reduce__(self): (1)
 def __eq__(self, other): (1)
 def __hash__(self): (1)
 def __getattr__(self, attr): (1)
 def __mro_entries__(self, bases): (1)
 if '_root' not in kwds: (1)
 @_TypedCacheSpecialForm (2)
 @_tp_cache(typed=True) (2)
 def decorator(func): (1)
 if func is not None: (1)
 return decorator (1)
 def Annotated(self, *params): (2)
 cache = functools.lru_cache(typed=typed)(func) (1)
functools.py (1) if isinstance(maxsize, int): (1)
 if maxsize < 0: (1)
 def decorating_function(user_function): (1)
 return decorating_function (1)
 wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo) (1)
 wrapper.cache_parameters = lambda : {'maxsize': maxsize, 'typed': typed} (1)
 return update_wrapper(wrapper, user_function) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 _caches[func] = cache (1)
 _cleanups.append(cache.cache_clear) (1)
 del cache (1)
 @functools.wraps(func) (2)
functools.py (2) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 def inner(*args, **kwds): (2)
 return inner (1)
 self._getitem = getitem (4)
 self._name = getitem.__name__ (4)
 self.__doc__ = getitem.__doc__ (4)
 def runtime_checkable(cls): (1)
 def cast(typ, val): (1)
 def assert_type(val, typ, /): (1)
 _allowed_types = (types.FunctionType, types.BuiltinFunctionType, (2)
 types.MethodType, types.ModuleType, (1)
 WrapperDescriptorType, MethodWrapperType, MethodDescriptorType) (1)
 def get_type_hints(obj, globalns=None, localns=None, include_extras=False): (1)
 def _strip_annotations(t): (1)
 def get_origin(tp): (1)
 def get_args(tp): (1)
 def is_typeddict(tp): (1)
 _ASSERT_NEVER_REPR_MAX_LENGTH = 100 (1)
 def assert_never(arg: Never, /) -> Never: (1)
 def no_type_check(arg): (1)
 def no_type_check_decorator(decorator): (1)
 def _overload_dummy(*args, **kwds): (1)
 _overload_registry = defaultdict(functools.partial(defaultdict, dict)) (1)
 def overload(func): (1)
 def get_overloads(func): (1)
 def clear_overloads(): (1)
 def final(f): (1)
 T = TypeVar('T')  # Any type. (1)
 KT = TypeVar('KT')  # Key type. (1)
 VT = TypeVar('VT')  # Value type. (1)
 T_co = TypeVar('T_co', covariant=True)  # Any type covariant containers. (1)
 V_co = TypeVar('V_co', covariant=True)  # Any type covariant containers. (1)
 VT_co = TypeVar('VT_co', covariant=True)  # Value type covariant containers. (1)
 T_contra = TypeVar('T_contra', contravariant=True)  # Ditto contravariant. (1)
 CT_co = TypeVar('CT_co', covariant=True, bound=type) (1)
 invalid_generic_forms = (Generic, Protocol) (10)
 if not allow_special_forms: (10)
 invalid_generic_forms += (ClassVar,) (10)
 if is_argument: (10)
 invalid_generic_forms += (Final,) (10)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (10)
 if arg is None: (13)
 if isinstance(arg, str): (13)
 return arg (13)
 if (isinstance(arg, _GenericAlias) and (10)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (10)
 if allow_special_forms and arg in (ClassVar, Final): (9)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (9)
 if type(arg) is tuple: (9)
 return arg (9)
 AnyStr = TypeVar('AnyStr', bytes, str) (1)
 _alias = _SpecialGenericAlias (1)
 Hashable = _alias(collections.abc.Hashable, 0)  # Not generic. (1)
 if name is None: (36)
 name = origin.__name__ (27)
 super().__init__(origin, inst=inst, name=name) (36)
 self._inst = inst (46)
 if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', '_defaults'}: (323)
 return attr.startswith('__') and attr.endswith('__') (335)
 super().__setattr__(attr, val) (322)
 self._name = name (46)
 self.__origin__ = origin (46)
 self.__slots__ = None  # This is not documented. (46)
 self._nparams = nparams (36)
 self._defaults = defaults (36)
 if origin.__module__ == 'builtins': (36)
 self.__doc__ = f'A generic version of {origin.__module__}.{origin.__qualname__}.' (30)
 Awaitable = _alias(collections.abc.Awaitable, 1) (1)
 Coroutine = _alias(collections.abc.Coroutine, 3) (1)
 AsyncIterable = _alias(collections.abc.AsyncIterable, 1) (1)
 AsyncIterator = _alias(collections.abc.AsyncIterator, 1) (1)
 Iterable = _alias(collections.abc.Iterable, 1) (1)
 Iterator = _alias(collections.abc.Iterator, 1) (1)
 Reversible = _alias(collections.abc.Reversible, 1) (1)
 Sized = _alias(collections.abc.Sized, 0)  # Not generic. (1)
 Container = _alias(collections.abc.Container, 1) (1)
 Collection = _alias(collections.abc.Collection, 1) (1)
 Callable = _CallableType(collections.abc.Callable, 2) (1)
 """Deprecated alias to collections.abc.Callable. (1)
 Callable.__doc__ = \ (1)
 AbstractSet = _alias(collections.abc.Set, 1, name='AbstractSet') (1)
 MutableSet = _alias(collections.abc.MutableSet, 1) (1)
 Mapping = _alias(collections.abc.Mapping, 2) (1)
 MutableMapping = _alias(collections.abc.MutableMapping, 2) (1)
 Sequence = _alias(collections.abc.Sequence, 1) (1)
 MutableSequence = _alias(collections.abc.MutableSequence, 1) (1)
 ByteString = _DeprecatedGenericAlias( (2)
 collections.abc.ByteString, 0, removal_version=(3, 17)  # Not generic. (1)
 super().__init__(origin, nparams, inst=inst, name=name) (1)
 self._removal_version = removal_version (1)
 setattr(self.__origin__, attr, val) (1)
 Tuple = _TupleType(tuple, -1, inst=False, name='Tuple') (1)
 self.__doc__ = f'A generic version of {origin.__qualname__}.' (6)
 """Deprecated alias to builtins.tuple. (1)
 Tuple.__doc__ = \ (1)
 List = _alias(list, 1, inst=False, name='List') (1)
 Deque = _alias(collections.deque, 1, name='Deque') (1)
 Set = _alias(set, 1, inst=False, name='Set') (1)
 FrozenSet = _alias(frozenset, 1, inst=False, name='FrozenSet') (1)
 MappingView = _alias(collections.abc.MappingView, 1) (1)
 KeysView = _alias(collections.abc.KeysView, 1) (1)
 ItemsView = _alias(collections.abc.ItemsView, 2) (1)
 ValuesView = _alias(collections.abc.ValuesView, 1) (1)
 Dict = _alias(dict, 2, inst=False, name='Dict') (1)
 DefaultDict = _alias(collections.defaultdict, 2, name='DefaultDict') (1)
 OrderedDict = _alias(collections.OrderedDict, 2) (1)
 Counter = _alias(collections.Counter, 1) (1)
 ChainMap = _alias(collections.ChainMap, 2) (1)
 Generator = _alias(collections.abc.Generator, 3, defaults=(types.NoneType, types.NoneType)) (1)
 AsyncGenerator = _alias(collections.abc.AsyncGenerator, 2, defaults=(types.NoneType,)) (1)
 Type = _alias(type, 1, inst=False, name='Type') (1)
 """Deprecated alias to builtins.type. (1)
 Type.__doc__ = \ (1)
 @runtime_checkable (3)
 class SupportsInt(Protocol): (2)
 """An ABC with one abstract method __int__.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __int__(self) -> int: (2)
 if name == "Protocol" and bases == (Generic,): (8)
 elif Protocol in bases: (8)
 for base in bases: (16)
 base in {object, Generic} (8)
 or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) (8)
 issubclass(base, Generic) (8)
 and getattr(base, "_is_protocol", False) (8)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (8)
<frozen abc> (8) (8)

 super().__init_subclass__(*args, **kwargs) (8)
 if not cls.__dict__.get('_is_protocol', False): (8)
 cls._is_protocol = any(b is Protocol for b in cls.__bases__) (16)
 if '__subclasshook__' not in cls.__dict__: (8)
 cls.__subclasshook__ = _proto_hook (8)
 if cls._is_protocol and cls.__init__ is Protocol.__init__: (8)
 cls.__init__ = _no_init_or_replace_init (8)
<frozen abc> (8) (8)
 (8)

 annotations = getattr(base, '__annotations__', {}) (8)
 for attr in (*base.__dict__, *annotations): (117)
 if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: (109)
 attrs.add(attr) (8)
 if not issubclass(cls, Generic) or not getattr(cls, '_is_protocol', False): (7)
 cls._is_runtime_protocol = True (7)
 cls.__non_callable_proto_members__ = set() (7)
 for attr in cls.__protocol_attrs__: (14)
 try: (7)
 is_callable = callable(getattr(cls, attr, None)) (7)
 if not is_callable: (7)
 return cls (7)
 @runtime_checkable (3)
 class SupportsFloat(Protocol): (2)
 """An ABC with one abstract method __float__.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __float__(self) -> float: (2)
 @runtime_checkable (3)
 class SupportsComplex(Protocol): (2)
 """An ABC with one abstract method __complex__.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __complex__(self) -> complex: (2)
 @runtime_checkable (3)
 class SupportsBytes(Protocol): (2)
 """An ABC with one abstract method __bytes__.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __bytes__(self) -> bytes: (2)
 @runtime_checkable (3)
 class SupportsIndex(Protocol): (2)
 """An ABC with one abstract method __index__.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __index__(self) -> int: (2)
 @runtime_checkable (3)
 class SupportsAbs[T](Protocol): (3)
 super().__init__(origin, inst=inst, name=name) (10)
 if not isinstance(args, tuple): (10)
 self.__args__ = tuple(... if a is _TypingEllipsis else (57)
 a for a in args) (47)
 enforce_default_ordering = origin in (Generic, Protocol) (10)
 self.__parameters__ = _collect_type_parameters( (20)
 args, (10)
 enforce_default_ordering=enforce_default_ordering, (10)
 default_encountered = False (15)
 type_var_tuple_encountered = False (15)
 parameters = [] (15)
 for t in args: (36)
 if isinstance(t, type): (21)
 elif isinstance(t, tuple): (11)
 elif hasattr(t, '__typing_subst__'): (11)
 if t not in parameters: (4)
 if enforce_default_ordering: (4)
 if type_var_tuple_encountered and t.has_default(): (3)
 if t.has_default(): (3)
 elif default_encountered: (3)
 parameters.append(t) (4)
 return tuple(parameters) (15)
 if not name: (10)
 self.__module__ = origin.__module__ (7)
 if isinstance(self.__origin__, _SpecialForm): (5)
 if self._name:  # generic version of an ABC or built-in class (5)
 if self.__origin__ is Generic: (5)
 if Protocol in bases: (3)
 return () (2)
 """An ABC with one abstract method __abs__ that is covariant in its return type.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __abs__(self) -> T: (2)
 error = Generic in cls.__orig_bases__ (5)
 if not isinstance(other, _GenericAlias): (15)
 return NotImplemented (15)
 tvars = _collect_type_parameters(cls.__orig_bases__) (5)
 pass (10)
 if attr in {'__name__', '__qualname__'}: (12)
 if '__origin__' in self.__dict__ and not _is_dunder(attr): (12)
 raise AttributeError(attr) (12)
 if _is_unpacked_typevartuple(t): (7)
 return ((not isinstance(x, type)) and (14)
 getattr(x, '__typing_is_unpacked_typevartuple__', False)) (7)
 for x in getattr(t, '__parameters__', ()): (10)
 if x not in parameters: (3)
 parameters.append(x) (3)
 gvars = None (5)
 for base in cls.__orig_bases__: (12)
 if (isinstance(base, _GenericAlias) and (7)
 base.__origin__ is Generic): (5)
 if gvars is not None: (3)
 gvars = base.__parameters__ (3)
 if gvars is not None: (5)
 tvarset = set(tvars) (3)
 gvarset = set(gvars) (3)
 if not tvarset <= gvarset: (3)
 tvars = gvars (3)
 @runtime_checkable (3)
 class SupportsRound[T](Protocol): (3)
 """An ABC with one abstract method __round__ that is covariant in its return type.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __round__(self, ndigits: int = 0) -> T: (2)
 def _make_nmtuple(name, types, module, defaults = ()): (1)
 _prohibited = frozenset({'__new__', '__init__', '__slots__', '__getnewargs__', (1)
 _special = frozenset({'__module__', '__name__', '__annotations__'}) (1)
 class NamedTupleMeta(type): (2)
 def __new__(cls, typename, bases, ns): (1)
 def NamedTuple(typename, fields=_sentinel, /, **kwargs): (1)
 _NamedTuple = type.__new__(NamedTupleMeta, 'NamedTuple', (), {}) (1)
 def _namedtuple_mro_entries(bases): (1)
 NamedTuple.__mro_entries__ = _namedtuple_mro_entries (1)
 def _get_typeddict_qualifiers(annotation_type): (1)
 class _TypedDictMeta(type): (2)
 def __new__(cls, name, bases, ns, total=True): (1)
 __call__ = dict  # static method (1)
 def __subclasscheck__(cls, other): (1)
 __instancecheck__ = __subclasscheck__ (1)
 def TypedDict(typename, fields=_sentinel, /, *, total=True): (1)
 _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {}) (1)
 TypedDict.__mro_entries__ = lambda bases: (_TypedDict,) (1)
 @_SpecialForm (2)
 def Required(self, parameters): (2)
 @_SpecialForm (2)
 def NotRequired(self, parameters): (2)
 @_SpecialForm (2)
 def ReadOnly(self, parameters): (2)
 class NewType: (2)
 """NewType creates simple unique types with almost zero runtime overhead. (1)
 __call__ = _idfunc (1)
 def __init__(self, name, tp): (1)
 def __mro_entries__(self, bases): (1)
 def __repr__(self): (1)
 def __reduce__(self): (1)
 def __or__(self, other): (1)
 def __ror__(self, other): (1)
 Text = str (1)
 TYPE_CHECKING = False (1)
 class IO(Generic[AnyStr]): (2)
 try: (10)
 return _caches[func](*args, **kwds) (10)
 if not isinstance(args, tuple): (3)
 args = (args,) (3)
 args = tuple(_type_convert(p) for p in args) (9)
 is_generic_or_protocol = cls in (Generic, Protocol) (3)
 if is_generic_or_protocol: (3)
 if not args: (1)
 if not all(_is_typevar_like(p) for p in args): (3)
 return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x) (1)
 if len(set(args)) != len(args): (1)
 return _GenericAlias(cls, args) (3)
 i = bases.index(self) (1)
 for b in bases[i+1:]: (1)
 return (self.__origin__,) (3)
 """Generic base class for TextIO and BinaryIO. (1)
 __slots__ = () (1)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def mode(self) -> str: (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def name(self) -> str: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def close(self) -> None: (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def closed(self) -> bool: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def fileno(self) -> int: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def flush(self) -> None: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def isatty(self) -> bool: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def read(self, n: int = -1) -> AnyStr: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def readable(self) -> bool: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def readline(self, limit: int = -1) -> AnyStr: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def readlines(self, hint: int = -1) -> List[AnyStr]: (2)
 if not isinstance(params, tuple): (1)
 params = (params,) (1)
 msg = "Parameters to generic types must be types." (1)
 params = tuple(_type_check(p, msg) for p in params) (3)
 if (self._defaults (1)
 actual_len = len(params) (1)
 if actual_len != self._nparams: (1)
 return self.copy_with(params) (1)
 return _GenericAlias(self.__origin__, params, (2)
 name=self._name, inst=self._inst) (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def seek(self, offset: int, whence: int = 0) -> int: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def seekable(self) -> bool: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def tell(self) -> int: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def truncate(self, size: int = None) -> int: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def writable(self) -> bool: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def write(self, s: AnyStr) -> int: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def writelines(self, lines: List[AnyStr]) -> None: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __enter__(self) -> 'IO[AnyStr]': (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __exit__(self, type, value, traceback) -> None: (2)
 class BinaryIO(IO[bytes]): (2)
 for param in cls.__parameters__: (4)
 prepare = getattr(param, '__typing_prepare_subst__', None) (2)
 if prepare is not None: (2)
 args = prepare(cls, args) (2)
 _check_generic_specialization(cls, args) (2)
 expected_len = len(cls.__parameters__) (2)
 if not expected_len: (2)
 actual_len = len(arguments) (2)
 if actual_len != expected_len: (2)
 new_args = [] (2)
 for param, new_arg in zip(cls.__parameters__, args): (4)
 if isinstance(param, TypeVarTuple): (2)
 new_args.append(new_arg) (2)
 args = tuple(new_args) (2)
 """Typed version of the return of open() in binary mode.""" (1)
 __slots__ = () (1)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def write(self, s: Union[bytes, bytearray]) -> int: (2)
 return self._getitem(self, parameters) (4)
 if parameters == (): (3)
 if not isinstance(parameters, tuple): (3)
 msg = "Union[arg, ...]: each arg must be a type." (3)
 parameters = tuple(_type_check(p, msg) for p in parameters) (12)
 parameters = _remove_dups_flatten(parameters) (3)
 params = [] (3)
 for p in parameters: (9)
 if isinstance(p, (_UnionGenericAlias, types.UnionType)): (6)
 params.append(p) (6)
 return tuple(_deduplicate(params, unhashable_fallback=True)) (3)
 try: (3)
 return dict.fromkeys(params) (3)
 if len(parameters) == 1: (3)
 if len(parameters) == 2 and type(None) in parameters: (3)
 return _UnionGenericAlias(self, parameters) (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __enter__(self) -> 'BinaryIO': (2)
 class TextIO(IO[str]): (2)
 """Typed version of the return of open() in text mode.""" (1)
 __slots__ = () (1)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def buffer(self) -> BinaryIO: (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def encoding(self) -> str: (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def errors(self) -> Optional[str]: (2)
 arg = _type_check(parameters, f"{self} requires a single type.") (1)
 return 'typing.' + self._name (1)
 return Union[arg, type(None)] (1)
 return _UnionGenericAlias(self, parameters, name="Optional") (1)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def line_buffering(self) -> bool: (2)
 @property (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def newlines(self) -> Any: (2)
 @abstractmethod (2)
<frozen abc> (1) (1)
 (1)

 def __enter__(self) -> 'TextIO': (2)
 def reveal_type[T](obj: T, /) -> T: (2)
 class _IdentityCallable(Protocol): (2)
 def __call__[T](self, arg: T, /) -> T: (2)
 eq_default: bool = True, (2)
 order_default: bool = False, (2)
 kw_only_default: bool = False, (2)
 frozen_default: bool = False, (2)
 field_specifiers: tuple[type[Any] | Callable[..., Any], ...] = (), (2)
 def dataclass_transform( (8)
 if not isinstance(params, tuple) or len(params) != 2: (1)
 args, result = params (1)
 if isinstance(args, list): (1)
 params = (args, result) (1)
 return self.__getitem_inner__(params) (1)
 args, result = params (1)
 msg = "Callable[args, result]: result must be a type." (1)
 result = _type_check(result, msg) (1)
 return arg (1)
 if args is Ellipsis: (1)
 return self.copy_with((_TypingEllipsis, result)) (1)
 return _CallableGenericAlias(self.__origin__, params, (2)
 name=self._name, inst=self._inst) (1)
 return Union[left, self] (1)
 return hash((self.__origin__, self.__args__)) (2)
 arg.__origin__ in invalid_generic_forms): (1)
 **kwargs: Any, (1)
 ) -> _IdentityCallable: (1)
 type _Func = Callable[..., Any] (1)
 def override[F: _Func](method: F, /) -> F: (2)
 def is_protocol(tp: type, /) -> bool: (1)
 def get_protocol_members(tp: type, /) -> frozenset[str]: (1)
 def __getattr__(attr): (1)

<frozen importlib._bootstrap_external> (1) (2)
 (1)

_scalars.py (1) _CharLike_co: TypeAlias = str | bytes (1)
 _BoolLike_co: TypeAlias = bool | np.bool (1)
 _UIntLike_co: TypeAlias = np.unsignedinteger[Any] | _BoolLike_co (1)
 _IntLike_co: TypeAlias = int | np.integer[Any] | _BoolLike_co (1)
 _FloatLike_co: TypeAlias = float | np.floating[Any] | _IntLike_co (1)
 complex (3)
 | np.complexfloating[Any, Any] (1)
 | _FloatLike_co (1)
 _ComplexLike_co: TypeAlias = ( (1)
 _TD64Like_co: TypeAlias = np.timedelta64 | _IntLike_co (1)
 _NumberLike_co: TypeAlias = int | float | complex | np.number[Any] | np.bool (1)
 _ScalarLike_co: TypeAlias = int | float | complex | str | bytes | np.generic (1)
 _VoidLike_co: TypeAlias = tuple[Any, ...] | np.void (1)

_dtype_like.py (1) from ._shape import _ShapeLike (1)

_array_like.py (1) from numpy import ( (1)

_function_base_impl.py (2) import numpy._core.numeric as _nx (1)
 from numpy._core import transpose, overrides (1)

_histograms_impl.py (1) from numpy._core import overrides (1)

_nanfunctions_impl.py (2) import numpy._core.numeric as _nx (1)
 from numpy.lib import _function_base_impl as fnb (1)

_shape_base_impl.py (1) from numpy._core.numeric import asarray, zeros, zeros_like, array, asanyarray (1)
 from numpy._core.fromnumeric import reshape, transpose (1)
 from numpy._core.multiarray import normalize_axis_index (1)
 from numpy._core._multiarray_umath import _array_converter (1)
 from numpy._core import overrides (1)

_arraysetops_impl.py (1) from numpy._core import overrides (1)

_polynomial_impl.py (1) from numpy._core import (isscalar, abs, finfo, atleast_1d, hstack, dot, array, (1)

_arraypad_impl.py (1) from numpy._core.overrides import array_function_dispatch (1)
 from numpy.lib._index_tricks_impl import ndindex (1)
 __all__ = ['pad'] (1)
 def _round_if_needed(arr, dtype): (1)
 def _slice_at_axis(sl, axis): (1)
 def _view_roi(array, original_area_slice, axis): (1)
 def _pad_simple(array, pad_width, fill_value=None): (1)
 def _set_pad_area(padded, axis, width_pair, value_pair): (1)
 def _get_edges(padded, axis, width_pair): (1)
 def _get_linear_ramps(padded, axis, width_pair, end_value_pair): (1)
 def _get_stats(padded, axis, width_pair, length_pair, stat_func): (1)
 original_period, include_edge=False): (1)
 def _set_reflect_both(padded, axis, width_pair, method, (1)
 def _set_wrap_both(padded, axis, width_pair, original_period): (1)
 def _as_pairs(x, ndim, as_index=False): (1)
 def _pad_dispatcher(array, pad_width, mode=None, **kwargs): (1)
 @array_function_dispatch(_pad_dispatcher, module='numpy') (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def pad(array, pad_width, mode='constant', **kwargs): (2)

 (376)
 (376)
 (376)
 (376)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
 (101)
__init__.py (19) def set_module(module): (2)
 def _rename_parameter(old_names, new_names, dep_version=None): (2)
 from ._expired_attrs_2_0 import __expired_attributes__ (3)
 from . import version (2)
 from .memmap import * (1)
 from . import function_base (1)
 from _ctypes import _Pointer (1)
 from _ctypes import CFuncPtr as _CFuncPtr (1)
 from _ctypes import __version__ as _ctypes_version (1)
 from _ctypes import RTLD_LOCAL, RTLD_GLOBAL (1)
 from _ctypes import ArgumentError (1)
 from _ctypes import SIZEOF_TIME_T (1)
 if __version__ != _ctypes_version: (1)
 if _os.name == "nt": (1)
 from _ctypes import FormatError (1)
 DEFAULT_MODE = RTLD_LOCAL (1)
 if _os.name == "posix" and _sys.platform == "darwin": (1)
 def create_string_buffer(init, size=None): (1)
 c_buffer = create_string_buffer (1)
 _c_functype_cache = {} (1)
 def CFUNCTYPE(restype, *argtypes, **kw): (1)
 if _os.name == "nt": (1)
 from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL (1)
 _win_functype_cache = {} (1)
 def WINFUNCTYPE(restype, *argtypes, **kw): (1)
 if WINFUNCTYPE.__doc__: (1)
 from _ctypes import sizeof, byref, addressof, alignment, resize (1)
 from _ctypes import get_errno, set_errno (1)
 from _ctypes import _SimpleCData (1)
 def _check_size(typ, typecode=None): (1)
 class py_object(_SimpleCData): (2)
 _type_ = "O" (1)
 def __repr__(self): (1)
 _check_size(py_object, "P") (1)
 from struct import calcsize (15)
 if typecode is None: (14)
 actual, required = sizeof(typ), calcsize(typecode) (14)
 if actual != required: (14)
 class c_short(_SimpleCData): (2)
 _type_ = "h" (1)
 _check_size(c_short) (1)
 typecode = typ._type_ (12)
 class c_ushort(_SimpleCData): (2)
 _type_ = "H" (1)
 _check_size(c_ushort) (1)
 class c_long(_SimpleCData): (2)
 _type_ = "l" (1)
 _check_size(c_long) (1)
 class c_ulong(_SimpleCData): (2)
 _type_ = "L" (2)
_pytesttester.py (1) self.module_name = module_name (1)
 self.__module__ = module_name (1)

 _check_size(c_ulong) (2)
 if _calcsize("i") == _calcsize("l"): (1)
 c_int = c_long (1)
 c_uint = c_ulong (1)
 class c_float(_SimpleCData): (2)
 _type_ = "f" (1)
 _check_size(c_float) (1)
 class c_double(_SimpleCData): (2)
 _type_ = "d" (1)
 _check_size(c_double) (1)
 class c_longdouble(_SimpleCData): (2)
 _type_ = "g" (1)
 if sizeof(c_longdouble) == sizeof(c_double): (1)
 c_longdouble = c_double (1)
 if _calcsize("l") == _calcsize("q"): (1)
 class c_longlong(_SimpleCData): (2)
 _type_ = "q" (1)
 _check_size(c_longlong) (1)
 class c_ulonglong(_SimpleCData): (2)
 _type_ = "Q" (1)
 _check_size(c_ulonglong) (1)
 class c_ubyte(_SimpleCData): (2)
 _type_ = "B" (1)
 c_ubyte.__ctype_le__ = c_ubyte.__ctype_be__ = c_ubyte (1)
 _check_size(c_ubyte) (1)
 class c_byte(_SimpleCData): (2)
 _type_ = "b" (1)
 c_byte.__ctype_le__ = c_byte.__ctype_be__ = c_byte (1)
 _check_size(c_byte) (1)
 class c_char(_SimpleCData): (2)
 _type_ = "c" (1)
 c_char.__ctype_le__ = c_char.__ctype_be__ = c_char (1)
 _check_size(c_char) (1)
 class c_char_p(_SimpleCData): (2)
 _type_ = "z" (1)
 def __repr__(self): (1)
 _check_size(c_char_p, "P") (1)
 class c_void_p(_SimpleCData): (2)
 _type_ = "P" (1)
 c_voidp = c_void_p # backwards compatibility (to a bug) (1)
 _check_size(c_void_p) (1)
 class c_bool(_SimpleCData): (2)
 _type_ = "?" (1)
 from _ctypes import POINTER, pointer, _pointer_type_cache (1)
 class c_wchar_p(_SimpleCData): (2)
 _type_ = "Z" (1)
 def __repr__(self): (1)
 class c_wchar(_SimpleCData): (2)
 _type_ = "u" (1)
 def _reset_cache(): (1)
 def create_unicode_buffer(init, size=None): (1)
 def SetPointerType(pointer, cls): (1)
 def ARRAY(typ, len): (1)
 class CDLL(object): (2)
 """An instance of this class represents a loaded dll/shared (1)
 _func_flags_ = _FUNCFLAG_CDECL (1)
 _func_restype_ = c_int (1)
 _name = '<uninitialized>' (1)
 _handle = 0 (1)
 _FuncPtr = None (1)
 def __init__(self, name, mode=DEFAULT_MODE, handle=None, (2)
 use_errno=False, (1)
 use_last_error=False, (1)
 winmode=None): (1)
 def __repr__(self): (1)
 def __getattr__(self, name): (1)
 def __getitem__(self, name_or_ordinal): (1)
 class PyDLL(CDLL): (2)
 """This class represents the Python library itself.  It allows (1)
 _func_flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI (1)
 if _os.name == "nt": (1)
 class WinDLL(CDLL): (2)
 """This class represents a dll exporting functions using the (1)
 _func_flags_ = _FUNCFLAG_STDCALL (1)
 from _ctypes import _check_HRESULT, _SimpleCData (1)
 class HRESULT(_SimpleCData): (2)
 _type_ = "l" (1)
 _check_retval_ = _check_HRESULT (1)
 class OleDLL(CDLL): (2)
 """This class represents a dll exporting functions using the (1)
 _func_flags_ = _FUNCFLAG_STDCALL (1)
 _func_restype_ = HRESULT (1)
 class LibraryLoader(object): (2)
 def __init__(self, dlltype): (1)
 def __getattr__(self, name): (1)
 def __getitem__(self, name): (1)
 def LoadLibrary(self, name): (1)
 __class_getitem__ = classmethod(_types.GenericAlias) (1)
 cdll = LibraryLoader(CDLL) (1)
 self._dlltype = dlltype (4)
 pydll = LibraryLoader(PyDLL) (1)
 if _os.name == "nt": (1)
 pythonapi = PyDLL("python dll", None, _sys.dllhandle) (1)
 if name: (2)
 name = _os.fspath(name) (2)
 if name.endswith(".fwork"): (2)
 self._name = name (2)
 flags = self._func_flags_ (2)
 if use_errno: (2)
 if use_last_error: (2)
 if _sys.platform.startswith("aix"): (2)
 if _os.name == "nt": (2)
 if winmode is not None: (2)
 import nt (2)
 mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS (2)
 if '/' in name or '\\' in name: (2)
 class _FuncPtr(_CFuncPtr): (4)
 _flags_ = flags (2)
 _restype_ = self._func_restype_ (2)
 self._FuncPtr = _FuncPtr (2)
 if handle is None: (2)
 self._handle = handle (1)
 if _os.name == "nt": (1)
 windll = LibraryLoader(WinDLL) (1)
 oledll = LibraryLoader(OleDLL) (1)
 GetLastError = windll.kernel32.GetLastError (1)
 if name[0] == '_': (1)
 try: (1)
 dll = self._dlltype(name) (1)
 self._handle = _dlopen(self._name, mode) (1)
 setattr(self, name, dll) (1)
 return dll (1)
 if name.startswith('__') and name.endswith('__'): (1)
 func = self.__getitem__(name) (1)
 func = self._FuncPtr((name_or_ordinal, self)) (1)
 if not isinstance(name_or_ordinal, int): (1)
 func.__name__ = name_or_ordinal (1)
 return func (1)
 setattr(self, name, func) (1)
 return func (1)
 from _ctypes import get_last_error, set_last_error (1)
 def WinError(code=None, descr=None): (1)
 if sizeof(c_uint) == sizeof(c_void_p): (1)
 elif sizeof(c_ulong) == sizeof(c_void_p): (1)
 elif sizeof(c_ulonglong) == sizeof(c_void_p): (1)
 c_size_t = c_ulonglong (1)
 c_ssize_t = c_longlong (1)
 from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr (1)
 memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr) (1)
 flags = _FUNCFLAG_CDECL (2)
 if kw.pop("use_errno", False): (2)
 if kw.pop("use_last_error", False): (2)
 if kw: (2)
 try: (2)
 return _c_functype_cache[(restype, argtypes, flags)] (3)
 except KeyError: (2)
 pass (2)
 class CFunctionType(_CFuncPtr): (5)
 _argtypes_ = argtypes (2)
 _restype_ = restype (2)
 _flags_ = flags (2)
 return CFunctionType (2)
 memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr) (1)
 def PYFUNCTYPE(restype, *argtypes): (1)
 _cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr) (1)
 class CFunctionType(_CFuncPtr): (6)
 _argtypes_ = argtypes (3)
 _restype_ = restype (3)
 _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI (3)
 return CFunctionType (3)
 def cast(obj, typ): (1)
 _string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr) (1)
 def string_at(ptr, size=-1): (1)
 try: (1)
 from _ctypes import _wstring_at_addr (1)
 _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr) (1)
 def wstring_at(ptr, size=-1): (1)
 if _os.name == "nt": # COM stuff (1)
 def DllGetClassObject(rclsid, riid, ppv): (1)
 def DllCanUnloadNow(): (1)
 from ctypes._endian import BigEndianStructure, LittleEndianStructure (1)
 from ctypes._endian import BigEndianUnion, LittleEndianUnion (1)
 c_int8 = c_byte (1)
 c_uint8 = c_ubyte (1)
 for kind in [c_short, c_int, c_long, c_longlong]: (5)
 if sizeof(kind) == 2: c_int16 = kind (4)
 elif sizeof(kind) == 4: c_int32 = kind (3)
 elif sizeof(kind) == 8: c_int64 = kind (1)
 for kind in [c_ushort, c_uint, c_ulong, c_ulonglong]: (5)
 if sizeof(kind) == 2: c_uint16 = kind (4)
 elif sizeof(kind) == 4: c_uint32 = kind (3)
 elif sizeof(kind) == 8: c_uint64 = kind (1)
 del(kind) (1)
 if SIZEOF_TIME_T == 8: (1)
 c_time_t = c_int64 (1)
 _reset_cache() (1)
 _pointer_type_cache.clear() (1)
 _c_functype_cache.clear() (1)
 if _os.name == "nt": (1)
 _win_functype_cache.clear() (1)
 POINTER(c_wchar).from_param = c_wchar_p.from_param (1)
 POINTER(c_char).from_param = c_char_p.from_param (1)
 _pointer_type_cache[None] = c_void_p (1)
 from . import _core (1)
 from ._nested_sequence import ( (1)
 from ._nbit_base import ( (1)
 from ._nbit import ( (1)
 from ._char_codes import ( (1)
 from ._scalars import ( (1)
 from ._array_like import ( (1)
 _core.getlimits._register_known_types() (1)
getlimits.py (1) f16 = ntypes.float16 (1)
 float16_ma = MachArLike(f16, (2)
 machep=-10, (1)
 negep=-11, (1)
 minexp=-14, (1)
 maxexp=16, (1)
 it=10, (1)
 iexp=5, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=exp2(f16(-10)), (1)
 epsneg=exp2(f16(-11)), (1)
 huge=f16(65504), (1)
 tiny=f16(2 ** -14)) (1)
 self.params = _MACHAR_PARAMS[ftype] (4)
 self.ftype = ftype (4)
 self.title = self.params['title'] (4)
 if not smallest_subnormal: (4)
 self._smallest_subnormal = nextafter( (8)
 self.ftype(0), self.ftype(1), dtype=self.ftype) (4)
 self.epsilon = self.eps = self._float_to_float(eps) (4)
 return _fr1(self._float_conv(value)) (24)
 return array([value], self.ftype) (28)
 if a.size == 1: (24)
 a = a.copy() (24)
 a.shape = () (24)
 return a (24)
 self.epsneg = self._float_to_float(epsneg) (4)
 self.xmax = self.huge = self._float_to_float(huge) (4)
 self.xmin = self._float_to_float(tiny) (4)
 self.smallest_normal = self.tiny = self._float_to_float(tiny) (4)
 self.ibeta = self.params['itype'](ibeta) (4)
 self.__dict__.update(kwargs) (4)
 self.precision = int(-log10(self.eps)) (4)
 self.resolution = self._float_to_float( (8)
 self._float_conv(10) ** (-self.precision)) (4)
 self._str_eps = self._float_to_str(self.eps) (4)
 return self.params['fmt'] % array(_fr0(value)[0], self.ftype) (19)
 if a.ndim == 0: (19)
 a = a.copy() (19)
 a.shape = (1,) (19)
 return a (19)
 self._str_epsneg = self._float_to_str(self.epsneg) (3)
 self._str_xmin = self._float_to_str(self.xmin) (3)
 self._str_xmax = self._float_to_str(self.xmax) (3)
 self._str_resolution = self._float_to_str(self.resolution) (3)
 self._str_smallest_normal = self._float_to_str(self.xmin) (3)
 _register_type(float16_ma, b'f\xae') (1)
 _KNOWN_TYPES[bytepat] = machar (3)
 _float_ma[16] = float16_ma (1)
 f32 = ntypes.float32 (1)
 float32_ma = MachArLike(f32, (2)
 machep=-23, (1)
 negep=-24, (1)
 minexp=-126, (1)
 maxexp=128, (1)
 it=23, (1)
 iexp=8, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=exp2(f32(-23)), (1)
 epsneg=exp2(f32(-24)), (1)
 huge=f32((1 - 2 ** -24) * 2**128), (1)
 tiny=exp2(f32(-126))) (1)
 _register_type(float32_ma, b'\xcd\xcc\xcc\xbd') (1)
 _float_ma[32] = float32_ma (1)
 f64 = ntypes.float64 (1)
 epsneg_f64 = 2.0 ** -53.0 (1)
 tiny_f64 = 2.0 ** -1022.0 (1)
 float64_ma = MachArLike(f64, (2)
 machep=-52, (1)
 negep=-53, (1)
 minexp=-1022, (1)
 maxexp=1024, (1)
 it=52, (1)
 iexp=11, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=2.0 ** -52.0, (1)
 epsneg=epsneg_f64, (1)
 huge=(1.0 - epsneg_f64) / tiny_f64 * f64(4), (1)
 tiny=tiny_f64) (1)
 _register_type(float64_ma, b'\x9a\x99\x99\x99\x99\x99\xb9\xbf') (1)
 _float_ma[64] = float64_ma (1)
 ld = ntypes.longdouble (1)
 epsneg_f128 = exp2(ld(-113)) (1)
 tiny_f128 = exp2(ld(-16382)) (1)
 with numeric.errstate(all='ignore'): (2)
_ufunc_config.py (2) self._token = None (1)
 self._call = call (1)
 self._all = all (1)
 self._divide = divide (1)
 self._over = over (1)
 self._under = under (1)
 self._invalid = invalid (1)
 if self._token is not None: (1)
 if self._call is _Unspecified: (1)
 extobj = _make_extobj( (2)
 all=self._all, divide=self._divide, over=self._over, (1)
 under=self._under, invalid=self._invalid) (1)
 self._token = _extobj_contextvar.set(extobj) (1)
 _extobj_contextvar.reset(self._token) (1)

 huge_f128 = (ld(1) - epsneg_f128) / tiny_f128 * ld(4) (1)
 float128_ma = MachArLike(ld, (2)
 machep=-112, (1)
 negep=-113, (1)
 minexp=-16382, (1)
 maxexp=16384, (1)
 it=112, (1)
 iexp=15, (1)
 ibeta=2, (1)
 irnd=5, (1)
 ngrd=0, (1)
 eps=exp2(ld(-112)), (1)
 epsneg=epsneg_f128, (1)
 huge=huge_f128, (1)
 tiny=tiny_f128) (1)


overrides.py (1) from numpy._core._multiarray_umath import ( (1)

datetime.py (1) from _datetime import __doc__ (1)
 __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", (1)

contextvars.py (1) __all__ = ('Context', 'ContextVar', 'Token', 'copy_context') (1)

printoptions.py (1) __all__ = ["format_options"] (1)
 "edgeitems": 3,  # repr N leading and trailing items of each dimension (1)
 "threshold": 1000,  # total items > triggers array summarization (1)
 "floatmode": "maxprec", (1)
 "precision": 8,  # precision of floating point representations (1)
 "suppress": False,  # suppress printing small floating values in exp format (1)
 "linewidth": 75, (1)
 "nanstr": "nan", (1)
 "infstr": "inf", (1)
 "sign": "-", (1)
 "formatter": None, (1)
 'legacy': sys.maxsize, (1)
 'override_repr': None, (1)
 default_format_options_dict = { (1)
 format_options = ContextVar( (2)
 "format_options", default=default_format_options_dict.copy()) (1)

numerictypes.py (4) import warnings (1)
 from . import multiarray as ma (1)
 from ._type_aliases import ( (1)
 from ._dtype import _kind_name (1)
 from builtins import bool, int, float, complex, object, str, bytes  # noqa: F401, UP029 (1)
 generic = allTypes['generic'] (1)
 genericTypeRank = ['bool', 'int8', 'uint8', 'int16', 'uint16', (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def maximum_sctype(t): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def issctype(rep): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def obj2sctype(rep, default=None): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def issubclass_(arg1, arg2): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def issubsctype(arg1, arg2): (2)
 class _PreprocessDTypeError(Exception): (2)
 pass (1)
 def _preprocess_dtype(dtype): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def isdtype(dtype, kind): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def issubdtype(arg1, arg2): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def sctype2char(sctype): (2)
 def _scalar_type_key(typ): (1)
 ScalarType = [int, float, complex, bool, bytes, str, memoryview] (1)
 ScalarType += sorted(set(sctypeDict.values()), key=_scalar_type_key) (1)
 dt = dtype(typ) (24)
 return (dt.kind.lower(), dt.itemsize) (24)
 ScalarType = tuple(ScalarType) (1)
 for key in allTypes: (53)
 globals()[key] = allTypes[key] (52)
 __all__.append(key) (52)
 del key (1)
 typecodes = {'Character': 'c', (2)
 'Integer': 'bhilqnp', (1)
 'UnsignedInteger': 'BHILQNP', (1)
 'Float': 'efdg', (1)
 'Complex': 'FDG', (1)
 'AllInteger': 'bBhHiIlLqQnNpP', (1)
 'AllFloat': 'efdgFDG', (1)
 'Datetime': 'Mm', (1)
 'All': '?bhilqnpBHILQNPefdgFDGSUVOMm'} (1)
 typeDict = sctypeDict (1)
 def _register_types(): (1)
 _register_types() (1)
 numbers.Integral.register(integer) (1)
<frozen abc> (1) (1)
 (1)

 numbers.Complex.register(inexact) (1)
<frozen abc> (1) (1)
 (4)

 numbers.Real.register(floating) (1)
<frozen abc> (1) (1)
 (3)

 numbers.Number.register(number) (1)
<frozen abc> (1) (1)
 (5)


numeric.py (1) bitwise_not = invert (1)
 ufunc = type(sin) (1)
 newaxis = None (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 __all__ = [ (1)
 a, dtype=None, order=None, subok=None, shape=None, *, device=None (2)
 def _zeros_like_dispatcher( (2)
 @array_function_dispatch(_zeros_like_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 a, dtype=None, order='K', subok=True, shape=None, *, device=None (2)
 def zeros_like( (3)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def ones(shape, dtype=None, order='C', *, device=None, like=None): (2)
 _ones_with_like = array_function_dispatch()(ones) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 a, dtype=None, order=None, subok=None, shape=None, *, device=None (2)
 def _ones_like_dispatcher( (2)
 @array_function_dispatch(_ones_like_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 a, dtype=None, order='K', subok=True, shape=None, *, device=None (2)
 def ones_like( (3)
 shape, fill_value, dtype=None, order=None, *, device=None, like=None (2)
 def _full_dispatcher( (2)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def full(shape, fill_value, dtype=None, order='C', *, device=None, like=None): (2)
 _full_with_like = array_function_dispatch()(full) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 a, fill_value, dtype=None, order=None, subok=None, shape=None, (1)
 def _full_like_dispatcher( (2)
 *, device=None (1)
 @array_function_dispatch(_full_like_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 a, fill_value, dtype=None, order='K', subok=True, shape=None, (1)
 def full_like( (3)
 *, device=None (1)
 def _count_nonzero_dispatcher(a, axis=None, *, keepdims=None): (1)
 @array_function_dispatch(_count_nonzero_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def count_nonzero(a, axis=None, *, keepdims=False): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def isfortran(a): (2)
 def _argwhere_dispatcher(a): (1)
 @array_function_dispatch(_argwhere_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def argwhere(a): (2)
 def _flatnonzero_dispatcher(a): (1)
 @array_function_dispatch(_flatnonzero_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def flatnonzero(a): (2)
 def _correlate_dispatcher(a, v, mode=None): (1)
 @array_function_dispatch(_correlate_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def correlate(a, v, mode='valid'): (2)
 def _convolve_dispatcher(a, v, mode=None): (1)
 @array_function_dispatch(_convolve_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def convolve(a, v, mode='full'): (2)
 def _outer_dispatcher(a, b, out=None): (1)
 @array_function_dispatch(_outer_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def outer(a, b, out=None): (2)
 def _tensordot_dispatcher(a, b, axes=None): (1)
 @array_function_dispatch(_tensordot_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tensordot(a, b, axes=2): (2)
 def _roll_dispatcher(a, shift, axis=None): (1)
 @array_function_dispatch(_roll_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def roll(a, shift, axis=None): (2)
 def _rollaxis_dispatcher(a, axis, start=None): (1)
 @array_function_dispatch(_rollaxis_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def rollaxis(a, axis, start=0): (2)
 @set_module("numpy.lib.array_utils") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def normalize_axis_tuple(axis, ndim, argname=None, allow_duplicate=False): (2)
 def _moveaxis_dispatcher(a, source, destination): (1)
 @array_function_dispatch(_moveaxis_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def moveaxis(a, source, destination): (2)
 def _cross_dispatcher(a, b, axisa=None, axisb=None, axisc=None, axis=None): (1)
 @array_function_dispatch(_cross_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None): (2)
 little_endian = (sys.byteorder == 'little') (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def indices(dimensions, dtype=int, sparse=False): (2)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromfunction(function, shape, *, dtype=float, like=None, **kwargs): (2)
 _fromfunction_with_like = array_function_dispatch()(fromfunction) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def _frombuffer(buf, dtype, shape, order): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def isscalar(element): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def binary_repr(num, width=None): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def base_repr(number, base=2, padding=0): (2)
 def _maketup(descr, val): (1)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def identity(n, dtype=None, *, like=None): (2)
 _identity_with_like = array_function_dispatch()(identity) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def _allclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None): (1)
 @array_function_dispatch(_allclose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False): (2)
 def _isclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None): (1)
 @array_function_dispatch(_isclose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False): (2)
 def _array_equal_dispatcher(a1, a2, equal_nan=None): (1)
 type(dtype(nt.bool)), (1)
 type(dtype(nt.int8)), (1)
 type(dtype(nt.int16)), (1)
 type(dtype(nt.int32)), (1)
 type(dtype(nt.int64)), (1)
 _no_nan_types = { (1)
 def _dtype_cannot_hold_nan(dtype): (1)
 @array_function_dispatch(_array_equal_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array_equal(a1, a2, equal_nan=False): (2)
 def _array_equiv_dispatcher(a1, a2): (1)
 @array_function_dispatch(_array_equiv_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array_equiv(a1, a2): (2)
 def _astype_dispatcher(x, dtype, /, *, copy=None, device=None): (1)
 @array_function_dispatch(_astype_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def astype(x, dtype, /, *, copy=True, device=None): (2)
 inf = PINF (1)
 nan = NAN (1)
 False_ = nt.bool(False) (1)
 True_ = nt.bool(True) (1)
 def extend_all(module): (1)
 from .umath import * (1)

_internal.py (1) IS_PYPY = sys.implementation.name == 'pypy' (1)
 if sys.byteorder == 'little': (1)
 _nbo = '<' (1)
 def _makenames_list(adict, align): (1)
 def _usefields(adict, align): (1)
 def _array_descr(descriptor): (1)
 format_re = re.compile(r'(?P<order1>[<>|=]?)' (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (118)
 try: (118)
 char = self.decoded_string[index] (118)
 if char == "\\": (117)
 self.index = index + 1 (117)
 self.next = char (117)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (6)
 itemsappend = items.append (6)
 sourcematch = source.match (6)
 start = source.tell() (6)
 return self.index - len(self.next or '') (28)
 while True: (6)
 itemsappend(_parse(source, state, verbose, nested + 1, (12)
 not nested and not items)) (6)
 subpattern = SubPattern(state) (6)
 self.state = state (16)
 if data is None: (16)
 data = [] (6)
 self.data = data (16)
 self.width = None (16)
 subpatternappend = subpattern.append (6)
 sourceget = source.get (6)
 sourcematch = source.match (6)
 _len = len (6)
 _ord = ord (6)
 while True: (32)
 this = source.next (32)
 if this is None: (32)
 if this in "|)": (31)
 sourceget() (26)
 this = self.next (68)
 self.__next() (68)
 return this (68)
 if verbose: (26)
 if this[0] == "\\": (26)
 elif this not in SPECIAL_CHARS: (24)
 elif this == "[": (22)
 elif this in REPEAT_CHARS: (15)
 elif this == ".": (5)
 elif this == "(": (5)
 start = source.tell() - 1 (5)
 capture = True (5)
 atomic = False (5)
 name = None (5)
 add_flags = 0 (5)
 del_flags = 0 (5)
 if sourcematch("?"): (5)
 if char == self.next: (70)
 self.__next() (21)
 return True (21)
 char = sourceget() (5)
 if char is None: (5)
 if char == "P": (5)
 if sourcematch("<"): (4)
 name = source.getuntil(">", "group name") (4)
 result = '' (4)
 while True: (28)
 c = self.next (28)
 self.__next() (28)
 if c is None: (28)
 if c == terminator: (28)
 result += c (24)
 if not result: (4)
 break (4)
 return result (4)
 source.checkgroupname(name, 1) (4)
 if not (self.istext or name.isascii()): (4)
 if not name.isidentifier(): (4)
 if capture: (5)
 try: (4)
 group = state.opengroup(name) (4)
 gid = self.groups (4)
 return len(self.groupwidths) (8)
 self.groupwidths.append(None) (4)
 if self.groups > MAXGROUPS: (4)
 if name is not None: (4)
 ogid = self.groupdict.get(name, None) (4)
 if ogid is not None: (4)
 self.groupdict[name] = gid (4)
 return gid (4)
 sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and (5)
 p = _parse_sub(source, state, sub_verbose, nested + 1) (5)
 here = source.tell() - 1 (7)
 set = [] (7)
 setappend = set.append (7)
 if source.next == '[': (7)
 negate = sourcematch("^") (7)
 return False (49)
 while True: (30)
 this = sourceget() (30)
 if this is None: (30)
 if this == "]" and set: (30)
 elif this[0] == "\\": (23)
 if set and this in '-&~|' and source.next == this: (23)
 code1 = LITERAL, _ord(this) (23)
 if sourcematch("-"): (23)
 if code1[0] is IN: (16)
 setappend(code1) (16)
 break (7)
 set = _uniq(set) (7)
 return list(dict.fromkeys(items)) (7)
 if _len(set) == 1 and set[0][0] is LITERAL: (7)
 if negate: (5)
 subpatternappend((IN, set)) (5)
 self.data.append(code) (16)
 here = source.tell() (10)
 if this == "?": (10)
 min, max = 0, 1 (5)
 if subpattern: (10)
 return len(self.data) (26)
 item = subpattern[-1:] (10)
 if isinstance(index, slice): (57)
 return SubPattern(self.state, self.data[index]) (10)
 if not item or item[0][0] is AT: (10)
 return self.data[index] (47)
 if item[0][0] in _REPEATCODES: (10)
 if item[0][0] is SUBPATTERN: (10)
 if sourcematch("?"): (10)
 elif sourcematch("+"): (10)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (10)
 self.data[index] = code (10)
 break # end of subpattern (5)
 for i in range(len(subpattern))[::-1]: (22)
 op, av = subpattern[i] (16)
 if op is SUBPATTERN: (16)
 return subpattern (6)
 if not sourcematch("|"): (6)
 break (6)
 if len(items) == 1: (6)
 return items[0] (6)
 if not source.match(")"): (5)
 if group is not None: (5)
 state.closegroup(group, p) (4)
 self.groupwidths[gid] = p.getwidth() (4)
 if self.width is not None: (14)
 lo = hi = 0 (14)
 for op, av in self.data: (35)
 if op is BRANCH: (21)
 elif op is ATOMIC_GROUP: (21)
 elif op is SUBPATTERN: (21)
 elif op in _REPEATCODES: (21)
 i, j = av[2].getwidth() (10)
 elif op in _UNITCODES: (11)
 lo = lo + 1 (11)
 hi = hi + 1 (11)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (14)
 return self.width (14)
 lo = lo + i * av[0] (10)
 if av[1] == MAXREPEAT and j: (10)
 hi = hi + j * av[1] (5)
 if atomic: (5)
 subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p))) (5)
 subpatternappend((LITERAL, _ord(this))) (2)
 elif this == "*": (5)
 min, max = 0, MAXREPEAT (4)
 if negate: (2)
 subpatternappend(set[0]) (2)
 that = sourceget() (7)
 if that is None: (7)
 if that == "]": (7)
 if that[0] == "\\": (7)
 if that == '-': (7)
 code2 = LITERAL, _ord(that) (7)
 if code1[0] != LITERAL or code2[0] != LITERAL: (7)
 lo = code1[1] (7)
 hi = code2[1] (7)
 if hi < lo: (7)
 setappend((RANGE, (lo, hi))) (7)
 hi = MAXWIDTH (5)
 index += 1 (2)
 try: (2)
 char += self.decoded_string[index] (2)
 elif char == ":": (1)
 capture = False (1)
 group = None (1)
 code = _escape(source, this, state) (2)
 code = CATEGORIES.get(escape) (2)
 if code: (2)
 code = ESCAPES.get(escape) (2)
 if code: (2)
 try: (2)
 c = escape[1:2] (2)
 if c == "x": (2)
 elif c == "u" and source.istext: (2)
 elif c == "U" and source.istext: (2)
 elif c == "N" and source.istext: (2)
 elif c == "0": (2)
 elif c in DIGITS: (2)
 if len(escape) == 2: (2)
 if c in ASCIILETTERS: (2)
 return LITERAL, ord(escape[1]) (2)
 subpatternappend(code) (2)
 elif this == "+": (1)
 min, max = 1, MAXREPEAT (1)
 group, add_flags, del_flags, p = item[0][1] (1)
 if group is None and not add_flags and not del_flags: (1)
 item = p (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 break # end of pattern (1)
 group, add_flags, del_flags, p = av (4)
 if group is None and not add_flags and not del_flags: (4)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (5)
 lo = hi = 0 (1)
 for op, av in self.data: (5)
 if op is BRANCH: (4)
 elif op is ATOMIC_GROUP: (4)
 elif op is SUBPATTERN: (4)
 i, j = av[-1].getwidth() (4)
 return self.width (4)
 lo = lo + i (4)
 hi = hi + j (4)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (1)
 return self.width (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 code.extend([INFO, 4, 0, lo, hi]) (1)
 return (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (15)
 _len = len (15)
 LITERAL_CODES = _LITERAL_CODES (15)
 REPEATING_CODES = _REPEATING_CODES (15)
 SUCCESS_CODES = _SUCCESS_CODES (15)
 ASSERT_CODES = _ASSERT_CODES (15)
 iscased = None (15)
 tolower = None (15)
 fixes = None (15)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (15)
 for op, av in pattern: (40)
_parser.py (35) if isinstance(index, slice): (35)
 return self.data[index] (35)

 if op in LITERAL_CODES: (25)
 elif op is IN: (19)
 elif op is ANY: (14)
 elif op in REPEATING_CODES: (14)
 elif op is SUBPATTERN: (4)
 group, add_flags, del_flags, p = av (4)
 if group: (4)
 emit(MARK) (4)
 emit((group-1)*2) (4)
 _compile(code, p, _combine_flags(flags, add_flags, del_flags)) (4)
 if add_flags & TYPE_FLAGS: (4)
 return (flags | add_flags) & ~del_flags (4)
 if _simple(av[2]): (10)
 if len(p) != 1: (10)
_parser.py (10) return len(self.data) (10)

 op, av = p[0] (9)
_parser.py (9) if isinstance(index, slice): (9)
 return self.data[index] (9)

 if op is SUBPATTERN: (9)
 return op in _UNIT_CODES (9)
 emit(REPEATING_CODES[op][2]) (9)
 skip = _len(code); emit(0) (9)
 emit(av[0]) (9)
 emit(av[1]) (9)
 _compile(code, av[2], flags) (9)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (5)
 out = [] (5)
 tail = [] (5)
 charmap = bytearray(256) (5)
 hascased = False (5)
 for op, av in charset: (26)
 while True: (21)
 try: (21)
 if op is LITERAL: (21)
 if fixup: # IGNORECASE and not LOCALE (14)
 charmap[av] = 1 (14)
 break (21)
 runs = [] (5)
 q = 0 (5)
 while True: (15)
 p = charmap.find(1, q) (15)
 if p < 0: (15)
 if len(runs) >= 2: (13)
 q = charmap.find(0, p) (10)
 if q < 0: (10)
 runs.append((p, q)) (10)
 break (2)
 if runs is not None: (5)
 for p, q in runs: (6)
 if q - p == 1: (4)
 out.append((RANGE, (p, q - 1))) (2)
 out.append((LITERAL, p)) (2)
 out += tail (2)
 if hascased or len(out) < len(charset): (2)
 return out, hascased (2)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (5)
 elif not hascased: (5)
 emit(IN) (5)
 skip = _len(code); emit(0) (5)
 _compile_charset(charset, flags, code) (5)
 emit = code.append (5)
 for op, av in charset: (12)
 emit(op) (7)
 if op is NEGATE: (7)
 elif op is LITERAL: (7)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (5)
 emit(av[0]) (2)
 emit(av[1]) (2)
 emit(av) (2)
 emit(FAILURE) (5)
 code[skip] = _len(code) - skip (5)
 emit(SUCCESS) (9)
 code[skip] = _len(code) - skip (9)
 if group: (4)
 emit(MARK) (4)
 emit((group-1)*2+1) (4)
 if not flags & SRE_FLAG_IGNORECASE: (6)
 emit(op) (6)
 emit(av) (6)
 elif op is RANGE: (7)
 r = range(av[0], av[1]+1) (7)
 if fixup: # IGNORECASE and not LOCALE (7)
 for i in r: (141)
 charmap[i] = 1 (134)
 runs = None (3)
 break (3)
 if len(charmap) == 256: (3)
 data = _mk_bitmap(charmap) (3)
 s = bits.translate(_BITS_TRANS)[::-1] (3)
 for i in range(len(s), 0, -_CODEBITS)] (30)
 return [_int(s[i - _CODEBITS: i], 2) (30)
 out.append((CHARSET, data)) (3)
 out += tail (3)
 return out, hascased (3)
 elif op is CHARSET: (3)
 code.extend(av) (3)
 return False (1)
 emit(REPEATING_CODES[op][0]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 code[skip] = _len(code) - skip (1)
 emit(REPEATING_CODES[op][1]) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (5)
 indexgroup[i] = k (4)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 sep_re = re.compile(r'\s*,\s*') (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (6)
 try: (6)
 char = self.decoded_string[index] (6)
 if char == "\\": (5)
 index += 1 (2)
 try: (2)
 char += self.decoded_string[index] (2)
 self.index = index + 1 (5)
 self.next = char (5)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (1)
 itemsappend = items.append (1)
 sourcematch = source.match (1)
 start = source.tell() (1)
 return self.index - len(self.next or '') (3)
 while True: (1)
 itemsappend(_parse(source, state, verbose, nested + 1, (2)
 not nested and not items)) (1)
 subpattern = SubPattern(state) (1)
 self.state = state (3)
 if data is None: (3)
 data = [] (1)
 self.data = data (3)
 self.width = None (3)
 subpatternappend = subpattern.append (1)
 sourceget = source.get (1)
 sourcematch = source.match (1)
 _len = len (1)
 _ord = ord (1)
 while True: (6)
 this = source.next (6)
 if this is None: (6)
 if this in "|)": (5)
 sourceget() (5)
 this = self.next (5)
 self.__next() (5)
 return this (5)
 if verbose: (5)
 if this[0] == "\\": (5)
 code = _escape(source, this, state) (2)
 code = CATEGORIES.get(escape) (2)
 if code: (2)
 return code (2)
 subpatternappend(code) (2)
 self.data.append(code) (3)
 elif this not in SPECIAL_CHARS: (3)
 elif this == "[": (2)
 elif this in REPEAT_CHARS: (2)
 here = source.tell() (2)
 if this == "?": (2)
 elif this == "*": (2)
 min, max = 0, MAXREPEAT (2)
 if subpattern: (2)
 return len(self.data) (5)
 item = subpattern[-1:] (2)
 if isinstance(index, slice): (11)
 return SubPattern(self.state, self.data[index]) (2)
 if not item or item[0][0] is AT: (2)
 return self.data[index] (9)
 if item[0][0] in _REPEATCODES: (2)
 if item[0][0] is SUBPATTERN: (2)
 if sourcematch("?"): (2)
 if char == self.next: (5)
 return False (5)
 elif sourcematch("+"): (2)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (2)
 self.data[index] = code (2)
 subpatternappend((LITERAL, _ord(this))) (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 break # end of pattern (1)
 for i in range(len(subpattern))[::-1]: (4)
 op, av = subpattern[i] (3)
 if op is SUBPATTERN: (3)
 return subpattern (1)
 if not sourcematch("|"): (1)
 break (1)
 if len(items) == 1: (1)
 return items[0] (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (3)
 lo = hi = 0 (3)
 for op, av in self.data: (8)
 if op is BRANCH: (5)
 elif op is ATOMIC_GROUP: (5)
 elif op is SUBPATTERN: (5)
 elif op in _REPEATCODES: (5)
 i, j = av[2].getwidth() (2)
 elif op in _UNITCODES: (3)
 lo = lo + 1 (3)
 hi = hi + 1 (3)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (3)
 return self.width (3)
 lo = lo + i * av[0] (2)
 if av[1] == MAXREPEAT and j: (2)
 hi = MAXWIDTH (2)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (1)
 prefixappend = prefix.append (1)
 prefix_skip = None (1)
 iscased = _get_iscased(flags) (1)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 return None (2)
 for op, av in pattern.data: (1)
 if op is LITERAL: (1)
 elif op is SUBPATTERN: (1)
 break (1)
 return prefix, prefix_skip, False (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (1)
 if not pattern.data: (1)
 op, av = pattern.data[0] (1)
 if op is not SUBPATTERN: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (3)
 _len = len (3)
 LITERAL_CODES = _LITERAL_CODES (3)
 REPEATING_CODES = _REPEATING_CODES (3)
 SUCCESS_CODES = _SUCCESS_CODES (3)
 ASSERT_CODES = _ASSERT_CODES (3)
 iscased = None (3)
 tolower = None (3)
 fixes = None (3)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (3)
 for op, av in pattern: (8)
_parser.py (4) if isinstance(index, slice): (4)
 return self.data[index] (4)

 if op in LITERAL_CODES: (5)
 elif op is IN: (4)
 elif op is ANY: (2)
 elif op in REPEATING_CODES: (2)
 if _simple(av[2]): (2)
 if len(p) != 1: (2)
_parser.py (2) return len(self.data) (2)

 op, av = p[0] (2)
_parser.py (2) if isinstance(index, slice): (2)
 return self.data[index] (2)

 if op is SUBPATTERN: (2)
 return op in _UNIT_CODES (2)
 emit(REPEATING_CODES[op][2]) (2)
 skip = _len(code); emit(0) (2)
 emit(av[0]) (2)
 emit(av[1]) (2)
 _compile(code, av[2], flags) (2)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (2)
 out = [] (2)
 tail = [] (2)
 charmap = bytearray(256) (2)
 hascased = False (2)
 for op, av in charset: (4)
 while True: (2)
 try: (2)
 if op is LITERAL: (2)
 elif op is RANGE: (2)
 elif op is NEGATE: (2)
 tail.append((op, av)) (2)
 break (2)
 runs = [] (2)
 q = 0 (2)
 while True: (2)
 p = charmap.find(1, q) (2)
 if p < 0: (2)
 break (2)
 if runs is not None: (2)
 for p, q in runs: (2)
 out += tail (2)
 if hascased or len(out) < len(charset): (2)
 return charset, hascased (2)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (2)
 elif not hascased: (2)
 emit(IN) (2)
 skip = _len(code); emit(0) (2)
 _compile_charset(charset, flags, code) (2)
 emit = code.append (2)
 for op, av in charset: (4)
 emit(op) (2)
 if op is NEGATE: (2)
 elif op is LITERAL: (2)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (2)
 elif op is CHARSET: (2)
 elif op is BIGCHARSET: (2)
 elif op is CATEGORY: (2)
 if flags & SRE_FLAG_LOCALE: (2)
 elif flags & SRE_FLAG_UNICODE: (2)
 emit(CH_UNICODE[av]) (2)
 emit(FAILURE) (2)
 code[skip] = _len(code) - skip (2)
 emit(SUCCESS) (2)
 code[skip] = _len(code) - skip (2)
 if not flags & SRE_FLAG_IGNORECASE: (1)
 emit(op) (1)
 emit(av) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 space_re = re.compile(r'\s+$') (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (4)
 try: (4)
 char = self.decoded_string[index] (4)
 if char == "\\": (3)
 index += 1 (1)
 try: (1)
 char += self.decoded_string[index] (1)
 self.index = index + 1 (3)
 self.next = char (3)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (1)
 itemsappend = items.append (1)
 sourcematch = source.match (1)
 start = source.tell() (1)
 return self.index - len(self.next or '') (2)
 while True: (1)
 itemsappend(_parse(source, state, verbose, nested + 1, (2)
 not nested and not items)) (1)
 subpattern = SubPattern(state) (1)
 self.state = state (2)
 if data is None: (2)
 data = [] (1)
 self.data = data (2)
 self.width = None (2)
 subpatternappend = subpattern.append (1)
 sourceget = source.get (1)
 sourcematch = source.match (1)
 _len = len (1)
 _ord = ord (1)
 while True: (4)
 this = source.next (4)
 if this is None: (4)
 if this in "|)": (3)
 sourceget() (3)
 this = self.next (3)
 self.__next() (3)
 return this (3)
 if verbose: (3)
 if this[0] == "\\": (3)
 code = _escape(source, this, state) (1)
 code = CATEGORIES.get(escape) (1)
 if code: (1)
 return code (1)
 subpatternappend(code) (1)
 self.data.append(code) (2)
 elif this not in SPECIAL_CHARS: (2)
 elif this == "[": (2)
 elif this in REPEAT_CHARS: (2)
 here = source.tell() (1)
 if this == "?": (1)
 elif this == "*": (1)
 elif this == "+": (1)
 min, max = 1, MAXREPEAT (1)
 if subpattern: (1)
 return len(self.data) (3)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (6)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (5)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 if char == self.next: (3)
 return False (3)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 elif this == ".": (1)
 elif this == "(": (1)
 elif this == "^": (1)
 elif this == "$": (1)
 subpatternappend((AT, AT_END)) (1)
 break # end of pattern (1)
 for i in range(len(subpattern))[::-1]: (3)
 op, av = subpattern[i] (2)
 if op is SUBPATTERN: (2)
 return subpattern (1)
 if not sourcematch("|"): (1)
 break (1)
 if len(items) == 1: (1)
 return items[0] (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (5)
 if op is BRANCH: (3)
 elif op is ATOMIC_GROUP: (3)
 elif op is SUBPATTERN: (3)
 elif op in _REPEATCODES: (3)
 i, j = av[2].getwidth() (1)
 elif op in _UNITCODES: (2)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = MAXWIDTH (1)
 elif op is GROUPREF: (1)
 elif op is GROUPREF_EXISTS: (1)
 elif op is SUCCESS: (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (1)
 prefixappend = prefix.append (1)
 prefix_skip = None (1)
 iscased = _get_iscased(flags) (1)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 return None (2)
 for op, av in pattern.data: (1)
 if op is LITERAL: (1)
 elif op is SUBPATTERN: (1)
 break (1)
 return prefix, prefix_skip, False (1)
 if not prefix: (1)
 charset = _get_charset_prefix(pattern, flags) (1)
 while True: (1)
 if not pattern.data: (1)
 op, av = pattern.data[0] (1)
 if op is not SUBPATTERN: (1)
 break (1)
 iscased = _get_iscased(flags) (1)
 if op is LITERAL: (1)
 elif op is BRANCH: (1)
 elif op is IN: (1)
 return None (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 elif charset: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 elif charset: (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (2)
 _len = len (2)
 LITERAL_CODES = _LITERAL_CODES (2)
 REPEATING_CODES = _REPEATING_CODES (2)
 SUCCESS_CODES = _SUCCESS_CODES (2)
 ASSERT_CODES = _ASSERT_CODES (2)
 iscased = None (2)
 tolower = None (2)
 fixes = None (2)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (2)
 for op, av in pattern: (5)
_parser.py (2) if isinstance(index, slice): (2)
 return self.data[index] (2)

 if op in LITERAL_CODES: (3)
 elif op is IN: (3)
 elif op is ANY: (2)
 elif op in REPEATING_CODES: (2)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (1)
 out = [] (1)
 tail = [] (1)
 charmap = bytearray(256) (1)
 hascased = False (1)
 for op, av in charset: (2)
 while True: (1)
 try: (1)
 if op is LITERAL: (1)
 elif op is RANGE: (1)
 elif op is NEGATE: (1)
 tail.append((op, av)) (1)
 break (1)
 runs = [] (1)
 q = 0 (1)
 while True: (1)
 p = charmap.find(1, q) (1)
 if p < 0: (1)
 break (1)
 if runs is not None: (1)
 for p, q in runs: (1)
 out += tail (1)
 if hascased or len(out) < len(charset): (1)
 return charset, hascased (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 elif not hascased: (1)
 emit(IN) (1)
 skip = _len(code); emit(0) (1)
 _compile_charset(charset, flags, code) (1)
 emit = code.append (1)
 for op, av in charset: (2)
 emit(op) (1)
 if op is NEGATE: (1)
 elif op is LITERAL: (1)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (1)
 elif op is CHARSET: (1)
 elif op is BIGCHARSET: (1)
 elif op is CATEGORY: (1)
 if flags & SRE_FLAG_LOCALE: (1)
 elif flags & SRE_FLAG_UNICODE: (1)
 emit(CH_UNICODE[av]) (1)
 emit(FAILURE) (1)
 code[skip] = _len(code) - skip (1)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 elif op is SUBPATTERN: (1)
 elif op is ATOMIC_GROUP: (1)
 elif op in SUCCESS_CODES: (1)
 elif op in ASSERT_CODES: (1)
 elif op is AT: (1)
 emit(op) (1)
 if flags & SRE_FLAG_MULTILINE: (1)
 if flags & SRE_FLAG_LOCALE: (1)
 elif flags & SRE_FLAG_UNICODE: (1)
 av = AT_UNICODE.get(av, av) (1)
 emit(av) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 _convorder = {'=': _nbo} (1)
 def _commastring(astr): (1)
 class dummy_ctype: (2)
 def __init__(self, cls): (1)
 def __mul__(self, other): (1)
 def __call__(self, *other): (1)
 def __eq__(self, other): (1)
 def __ne__(self, other): (1)
 def _getintp_ctype(): (1)
 _getintp_ctype.cache = None (1)
 class _missing_ctypes: (2)
 def cast(self, num, obj): (1)
 class c_void_p: (2)
 def __init__(self, ptr): (1)
 class _ctypes: (2)
 def __init__(self, array, ptr=None): (1)
 def data_as(self, obj): (1)
 def shape_as(self, obj): (1)
 def strides_as(self, obj): (1)
 @property (2)
 def data(self): (2)
 @property (2)
 def shape(self): (2)
 @property (2)
 def strides(self): (2)
 @property (2)
 def _as_parameter_(self): (2)
 def get_data(self): (1)
 def get_shape(self): (1)
 def get_strides(self): (1)
 def get_as_parameter(self): (1)
 def _newnames(datatype, order): (1)
 def _copy_fields(ary): (1)
 def _promote_fields(dt1, dt2): (1)
 def _getfield_is_safe(oldtype, newtype, offset): (1)
 def _view_is_safe(oldtype, newtype): (1)
 _pep3118_native_map = { (19)
 '?': '?', (1)
 'c': 'S1', (1)
 'b': 'b', (1)
 'B': 'B', (1)
 'h': 'h', (1)
 'H': 'H', (1)
 'i': 'i', (1)
 'I': 'I', (1)
 'l': 'l', (1)
 'L': 'L', (1)
 'q': 'q', (1)
 'Q': 'Q', (1)
 'e': 'e', (1)
 'f': 'f', (1)
 'd': 'd', (1)
 'g': 'g', (1)
 'Zf': 'F', (1)
 'Zd': 'D', (1)
 'Zg': 'G', (1)
 's': 'S', (1)
 'w': 'U', (1)
 'O': 'O', (1)
 'x': 'V',  # padding (1)
 _pep3118_native_typechars = ''.join(_pep3118_native_map.keys()) (1)
 _pep3118_standard_map = { (19)
 '?': '?', (1)
 'c': 'S1', (1)
 'b': 'b', (1)
 'B': 'B', (1)
 'h': 'i2', (1)
 'H': 'u2', (1)
 'i': 'i4', (1)
 'I': 'u4', (1)
 'l': 'i4', (1)
 'L': 'u4', (1)
 'q': 'i8', (1)
 'Q': 'u8', (1)
 'e': 'f2', (1)
 'f': 'f', (1)
 'd': 'd', (1)
 'Zf': 'F', (1)
 'Zd': 'D', (1)
 's': 'S', (1)
 'w': 'U', (1)
 'O': 'O', (1)
 'x': 'V',  # padding (1)
 _pep3118_standard_typechars = ''.join(_pep3118_standard_map.keys()) (1)
 'u': 'UCS-2 strings', (1)
 '&': 'pointers', (1)
 't': 'bitfields', (1)
 'X': 'function pointers', (1)
 _pep3118_unsupported_map = { (1)
 class _Stream: (2)
 def __init__(self, s): (1)
 def advance(self, n): (1)
 def consume(self, c): (1)
 def consume_until(self, c): (1)
 @property (2)
 def next(self): (2)
 def __bool__(self): (1)
 def _dtype_from_pep3118(spec): (1)
 def __dtype_from_pep3118(stream, is_subdtype): (1)
 def _fix_names(field_spec): (1)
 def _add_trailing_padding(value, padding): (1)
 def _prod(a): (1)
 def _gcd(a, b): (1)
 def _lcm(a, b): (1)
 def array_ufunc_errmsg_formatter(dummy, ufunc, method, *inputs, **kwargs): (1)
 def array_function_errmsg_formatter(public_api, types): (1)
 def _ufunc_doc_signature_formatter(ufunc): (1)
 def npy_ctypes_check(cls): (1)
 def _convert_to_stringdtype_kwargs(coerce, na_object=_NoValue): (1)

__config__.py (1) __all__ = ["show_config"] (1)
 _built_with_meson = True (1)
 class DisplayModes(Enum): (2)
enum.py (2) metacls._check_for_existing_members_(cls, bases) (1)
 for chain in bases: (2)
 for base in chain.__mro__: (3)
 if isinstance(base, EnumType) and base._member_names_: (2)
 enum_dict = EnumDict(cls) (1)
 super().__init__() (1)
 self._member_names = {} # use a dict -- faster look-up than a list, and keeps insertion order since 3.7 (1)
 self._last_values = [] (1)
 self._ignore = [] (1)
 self._auto_called = False (1)
 self._cls_name = cls_name (1)
 member_type, first_enum = metacls._get_mixins_(cls, bases) (1)
 if not bases: (1)
 first_enum = bases[-1] (1)
 if not isinstance(first_enum, EnumType): (1)
 member_type = mcls._find_data_type_(class_name, bases) or object (1)
 data_types = set() (1)
 base_chain = set() (1)
 for chain in bases: (2)
 candidate = None (1)
 for base in chain.__mro__: (3)
 base_chain.add(base) (2)
 if base is object: (2)
 elif isinstance(base, EnumType): (1)
 if base._member_type_ is not object: (1)
 continue (1)
 if len(data_types) > 1: (1)
 elif data_types: (1)
 return None (1)
 return member_type, first_enum (1)
 if first_enum is not None: (1)
 enum_dict['_generate_next_value_'] = getattr( (2)
 first_enum, '_generate_next_value_', None, (1)
 if self._cls_name is not None and _is_private(self._cls_name, key): (4)
 def _is_private(cls_name, name): (4)
 pattern = '_%s__' % (cls_name, ) (4)
 pat_len = len(pattern) (4)
 len(name) > pat_len (4)
 and name.startswith(pattern) (1)
 return False (4)
 elif _is_sunder(key): (4)
 len(name) > 2 and (12)
 name[0] == name[-1] == '_' and (4)
 name[1] != '_' and (4)
 name[-2] != '_' (1)
 return ( (4)
 if key not in ( (1)
 if key == '_generate_next_value_': (1)
 if self._auto_called: (1)
 _gnv = value.__func__ if isinstance(value, staticmethod) else value (1)
 setattr(self, '_generate_next_value', _gnv) (1)
 super().__setitem__(key, value) (4)
 return enum_dict (1)
 elif _is_dunder(key): (3)
 len(name) > 4 and (9)
 name[:2] == name[-2:] == '__' and (3)
 name[2] != '_' and (3)
 name[-3] != '_' (3)
 return ( (3)
 if key == '__order__': (3)

 stdout = "stdout" (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (2)
 name[0] == name[-1] == '_' and (1)
 return ( (1)
 elif _is_dunder(key): (1)
 len(name) > 4 and (2)
 name[:2] == name[-2:] == '__' and (1)
 return ( (1)
 elif key in self._member_names: (1)
 elif key in self._ignore: (1)
 elif isinstance(value, nonmember): (1)
 elif isinstance(value, partial): (1)
 elif _is_descriptor(value): (1)
 return not isinstance(obj, partial) and ( (2)
 hasattr(obj, '__get__') or (2)
 hasattr(obj, '__set__') or (1)
 hasattr(obj, '__delete__') (1)
 elif self._cls_name is not None and _is_internal_class(self._cls_name, value): (1)
 if not isinstance(obj, type): (1)
 return False (1)
 if key in self: (1)
 elif isinstance(value, member): (1)
 non_auto_store = True (1)
 single = False (1)
 if isinstance(value, auto): (1)
 if isinstance(value, tuple) and any(isinstance(v, auto) for v in value): (1)
 self._member_names[key] = None (1)
 if non_auto_store: (1)
 self._last_values.append(value) (1)
 super().__setitem__(key, value) (1)

 dicts = "dicts" (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (2)
 def _is_private(cls_name, name): (2)
 pattern = '_%s__' % (cls_name, ) (2)
 pat_len = len(pattern) (2)
 len(name) > pat_len (2)
 return False (2)
 elif _is_sunder(key): (2)
 len(name) > 2 and (5)
 name[0] == name[-1] == '_' and (2)
 return ( (2)
 elif _is_dunder(key): (2)
 len(name) > 4 and (5)
 name[:2] == name[-2:] == '__' and (2)
 return ( (2)
 elif key in self._member_names: (1)
 elif key in self._ignore: (1)
 elif isinstance(value, nonmember): (1)
 elif isinstance(value, partial): (1)
 elif _is_descriptor(value): (1)
 return not isinstance(obj, partial) and ( (2)
 hasattr(obj, '__get__') or (2)
 hasattr(obj, '__set__') or (1)
 hasattr(obj, '__delete__') (1)
 elif self._cls_name is not None and _is_internal_class(self._cls_name, value): (1)
 if not isinstance(obj, type): (1)
 return False (1)
 if key in self: (1)
 elif isinstance(value, member): (1)
 non_auto_store = True (1)
 single = False (1)
 if isinstance(value, auto): (1)
 if isinstance(value, tuple) and any(isinstance(v, auto) for v in value): (1)
 self._member_names[key] = None (1)
 if non_auto_store: (1)
 self._last_values.append(value) (1)
 super().__setitem__(key, value) (2)
 and name.startswith(pattern) (1)
 name[1] != '_' and (1)
 name[2] != '_' and (1)
 name[-3] != '_' (1)
 if key == '__order__': (1)
 if _simple: (1)
 classdict.setdefault('_ignore_', []).append('_ignore_') (1)
 ignore = classdict['_ignore_'] (1)
 for key in ignore: (2)
 classdict.pop(key, None) (1)
 member_names = classdict._member_names (1)
 invalid_names = set(member_names) & {'mro', ''} (1)
 if invalid_names: (1)
 _order_ = classdict.pop('_order_', None) (1)
 _gnv = classdict.get('_generate_next_value_') (1)
 if _gnv is not None and type(_gnv) is not staticmethod: (1)
 _gnv = staticmethod(_gnv) (1)
 classdict = dict(classdict.items()) (1)
 if _gnv is not None: (1)
 classdict['_generate_next_value_'] = _gnv (1)
 member_type, first_enum = metacls._get_mixins_(cls, bases) (1)
 if not bases: (1)
 first_enum = bases[-1] (1)
 if not isinstance(first_enum, EnumType): (1)
 member_type = mcls._find_data_type_(class_name, bases) or object (1)
 data_types = set() (1)
 base_chain = set() (1)
 for chain in bases: (2)
 candidate = None (1)
 for base in chain.__mro__: (3)
 base_chain.add(base) (2)
 if base is object: (2)
 elif isinstance(base, EnumType): (1)
 if base._member_type_ is not object: (1)
 continue (1)
 if len(data_types) > 1: (1)
 elif data_types: (1)
 return None (1)
 return member_type, first_enum (1)
 __new__, save_new, use_args = metacls._find_new_( (2)
 classdict, member_type, first_enum, (1)
 __new__ = classdict.get('__new__', None) (1)
 save_new = first_enum is not None and __new__ is not None (1)
 if __new__ is None: (1)
 for method in ('__new_member__', '__new__'): (3)
 for possible in (member_type, first_enum): (6)
 target = getattr(possible, method, None) (4)
 if target not in { (8)
 None, (4)
 None.__new__, (4)
 object.__new__, (4)
 Enum.__new__, (4)
 if __new__ is not None: (2)
 __new__ = object.__new__ (1)
 if first_enum is None or __new__ in (Enum.__new__, object.__new__): (1)
 use_args = False (1)
 return __new__, save_new, use_args (1)
 classdict['_new_member_'] = __new__ (1)
 classdict['_use_args_'] = use_args (1)
 for name in member_names: (3)
 value = classdict[name] (2)
 classdict[name] = _proto_member(value) (2)
 self.value = value (2)
 classdict['_member_names_'] = [] (1)
 classdict['_member_map_'] = {} (1)
 classdict['_value2member_map_'] = {} (1)
 classdict['_hashable_values_'] = []          # for comparing with non-hashable types (1)
 classdict['_unhashable_values_'] = []       # e.g. frozenset() with set() (1)
 classdict['_unhashable_values_map_'] = {} (1)
 classdict['_member_type_'] = member_type (1)
 classdict['_value_repr_'] = metacls._find_data_repr_(cls, bases) (1)
 for chain in bases: (1)
 for base in chain.__mro__: (1)
 if base is object: (1)
 elif isinstance(base, EnumType): (1)
 return base._value_repr_ (1)
 boundary (1)
 or getattr(first_enum, '_boundary_', None) (1)
 classdict['_boundary_'] = ( (1)
 classdict['_flag_mask_'] = 0 (1)
 classdict['_singles_mask_'] = 0 (1)
 classdict['_all_bits_'] = 0 (1)
 classdict['_inverted_'] = None (1)
 try: (1)
 classdict['_%s__in_progress' % cls] = True (1)
 enum_class = super().__new__(metacls, cls, bases, classdict, **kwds) (1)
 delattr(enum_class, member_name) (2)
 if attr in cls._member_map_: (8)
 super().__delattr__(attr) (8)
 value = self.value (2)
 if not isinstance(value, tuple): (2)
 args = (value, ) (2)
 if enum_class._member_type_ is tuple:   # special case for tuple enums (2)
 if not enum_class._use_args_: (2)
 enum_member = enum_class._new_member_(enum_class) (2)
 if not hasattr(enum_member, '_value_'): (2)
 if enum_class._member_type_ is object: (2)
 enum_member._value_ = value (2)
 value = enum_member._value_ (2)
 enum_member._name_ = member_name (2)
 enum_member.__objclass__ = enum_class (2)
 enum_member.__init__(*args) (2)
 pass (2)
 enum_member._sort_order_ = len(enum_class._member_names_) (2)
 if Flag is not None and issubclass(enum_class, Flag): (2)
 try: (2)
 try: (2)
 enum_member = enum_class._value2member_map_[value] (2)
 except TypeError: (2)
 except KeyError: (2)
 Flag is None (2)
 or not issubclass(enum_class, Flag) (2)
 enum_class._member_names_.append(member_name) (2)
 enum_class._add_member_(member_name, enum_member) (2)
 if name in cls._member_map_: (2)
 found_descriptor = None (2)
 descriptor_type = None (2)
 class_type = None (2)
 for base in cls.__mro__[1:]: (6)
 attr = base.__dict__.get(name) (4)
 if attr is not None: (4)
 if found_descriptor: (2)
 setattr(cls, name, member) (2)
 member_map = cls.__dict__.get('_member_map_', {}) (3)
 if name in member_map: (3)
 super().__setattr__(name, value) (3)
 cls._member_map_[name] = member (2)
 try: (2)
 enum_class._value2member_map_.setdefault(value, enum_member) (2)
 if value not in enum_class._hashable_values_: (2)
 enum_class._hashable_values_.append(value) (2)
 classdict['_%s__in_progress' % cls] = False (1)
 delattr(enum_class, '_%s__in_progress' % cls) (1)
 classdict.update(enum_class.__dict__) (1)
 if ReprEnum is not None and ReprEnum in bases: (1)
 for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'): (5)
 if name not in classdict: (4)
 enum_method = getattr(first_enum, name) (4)
 found_method = getattr(enum_class, name) (4)
 object_method = getattr(object, name) (4)
 data_type_method = getattr(member_type, name) (4)
 if found_method in (data_type_method, object_method): (4)
 if Flag is not None and issubclass(enum_class, Flag): (1)
 if Enum is not None: (1)
 if save_new: (1)
 enum_class.__new__ = Enum.__new__ (1)
 if _order_ is not None: (1)
 Flag is None and cls != 'Flag' (1)
 or Flag is not None and not issubclass(enum_class, Flag) (1)
 delattr(enum_class, '_boundary_') (1)
 delattr(enum_class, '_flag_mask_') (1)
 delattr(enum_class, '_singles_mask_') (1)
 delattr(enum_class, '_all_bits_') (1)
 delattr(enum_class, '_inverted_') (1)
 if _order_: (1)
 return enum_class (1)

 def _cleanup(d): (1)
 CONFIG = _cleanup( (2)
 "name": "msvc", (1)
 "linker": r"link", (1)
 "version": "19.29.30158", (1)
 "commands": r"cl", (1)
 "args": r"", (1)
 "linker args": r"", (1)
 "c": { (1)
 "name": "cython", (1)
 "linker": r"cython", (1)
 "version": "3.0.12", (1)
 "commands": r"cython", (1)
 "args": r"", (1)
 "linker args": r"", (1)
 "cython": { (1)
 "name": "msvc", (1)
 "linker": r"link", (1)
 "version": "19.29.30158", (1)
 "commands": r"cl", (1)
 "args": r"", (1)
 "linker args": r"", (1)
 "c++": { (1)
 "Compilers": { (1)
 "cpu": "x86_64", (1)
 "family": "x86_64", (1)
 "endian": "little", (1)
 "system": "windows", (1)
 "host": { (1)
 "cpu": "x86_64", (1)
 "family": "x86_64", (1)
 "endian": "little", (1)
 "system": "windows", (1)
 "build": { (1)
 "cross-compiled": bool("False".lower().replace("false", "")), (1)
 "Machine Information": { (1)
 "name": "scipy-openblas", (1)
 "found": bool("True".lower().replace("false", "")), (1)
 "version": "0.3.28", (1)
 "detection method": "pkgconfig", (1)
 "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-u8afkksu/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/include", (1)
 "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-u8afkksu/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/lib", (1)
 "openblas configuration": r"OpenBLAS 0.3.28  USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24", (1)
 "pc file directory": r"D:/a/numpy/numpy/.openblas", (1)
 "blas": { (1)
 "name": "scipy-openblas", (1)
 "found": bool("True".lower().replace("false", "")), (1)
 "version": "0.3.28", (1)
 "detection method": "pkgconfig", (1)
 "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-u8afkksu/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/include", (1)
 "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-u8afkksu/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/lib", (1)
 "openblas configuration": r"OpenBLAS 0.3.28  USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24", (1)
 "pc file directory": r"D:/a/numpy/numpy/.openblas", (1)
 "lapack": { (1)
 "Build Dependencies": { (1)
 "path": r"C:\Users\runneradmin\AppData\Local\Temp\build-env-vu_ki1u0\Scripts\python.exe", (1)
 "version": "3.13", (1)
 "Python Information": { (1)
 "baseline": __cpu_baseline__, (1)
 feature for feature in __cpu_dispatch__ if __cpu_features__[feature] (16)
 "found": [ (2)
 feature for feature in __cpu_dispatch__ if not __cpu_features__[feature] (16)
 "not found": [ (2)
 "SIMD Extensions": { (1)
 { (1)
 if isinstance(d, dict): (343)
 return {k: _cleanup(v) for k, v in d.items() if v and _cleanup(v)} (238)
 return d (304)
 def _check_pyyaml(): (1)
 def show(mode=DisplayModes.stdout.value): (1)
enum.py (1) if instance is None: (1)
 if self.fget is not None: (1)
 return self.fget(instance) (1)
 return self._value_ (1)

 def show_config(mode=DisplayModes.stdout.value): (1)
enum.py (1) if instance is None: (1)
 if self.fget is not None: (1)
 return self.fget(instance) (1)
 return self._value_ (1)

 show_config.__doc__ = show.__doc__ (1)
 show_config.__module__ = "numpy" (1)

_utils_impl.py (2) import types (1)
 import warnings (1)
 import functools (1)
 import platform (1)
 from numpy._core import ndarray (1)

platform.py (1) 'dev': 10, (1)
 'alpha': 20, 'a': 20, (1)
 'beta': 30, 'b': 30, (1)
 'c': 40, (1)
 'RC': 50, 'rc': 50, (1)
 'pl': 200, 'p': 200, (1)
 _ver_stages = { (1)
 def _comparable_version(version): (1)
 def libc_ver(executable=None, lib='', version='', chunksize=16384): (1)
 def _norm_version(version, build=''): (1)
 def _syscmd_ver(system='', release='', version='', (2)
 supported_platforms=('win32', 'win16', 'dos')): (1)
 def _wmi_query(table, *keys): (1)
 _WIN32_CLIENT_RELEASES = [ (1)
 _WIN32_SERVER_RELEASES = [ (1)
 def win32_is_iot(): (1)
 def win32_edition(): (1)
 def _win32_ver(version, csd, ptype): (1)
 def win32_ver(release='', version='', csd='', ptype=''): (1)
 def _mac_ver_xml(): (1)
 def mac_ver(release='', versioninfo=('', '', ''), machine=''): (1)
 IOSVersionInfo = collections.namedtuple( (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (6)
 if type(name) is not str: (5)
 if not name.isidentifier(): (5)
 if _iskeyword(name): (5)
 seen = set() (1)
 for name in field_names: (5)
 if name.startswith('_') and not rename: (4)
 if name in seen: (4)
 seen.add(name) (4)
 field_defaults = {} (1)
 if defaults is not None: (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (6)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (5)
 doc = _sys.intern(f'Alias for field number {index}') (4)
 class_namespace[name] = _tuplegetter(index, doc) (4)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 try: (1)
 module = _sys._getframemodulename(1) or '__main__' (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 "IOSVersionInfo", (1)
 ["system", "release", "model", "is_simulator"] (1)
 def ios_ver(system="", release="", model="", is_simulator=False): (1)
 def _java_getprop(name, default): (1)
 def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')): (1)
 AndroidVer = collections.namedtuple( (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = field_names.replace(',', ' ').split() (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (8)
 if type(name) is not str: (7)
 if not name.isidentifier(): (7)
 if _iskeyword(name): (7)
 seen = set() (1)
 for name in field_names: (7)
 if name.startswith('_') and not rename: (6)
 if name in seen: (6)
 seen.add(name) (6)
 field_defaults = {} (1)
 if defaults is not None: (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (8)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (7)
 doc = _sys.intern(f'Alias for field number {index}') (6)
 class_namespace[name] = _tuplegetter(index, doc) (6)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 try: (1)
 module = _sys._getframemodulename(1) or '__main__' (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 "AndroidVer", "release api_level manufacturer model device is_emulator") (1)
 def android_ver(release="", api_level=0, manufacturer="", model="", device="", (2)
 is_emulator=False): (1)
 def system_alias(system, release, version): (1)
 def _platform(*args): (1)
 def _node(default=''): (1)
 def _follow_symlinks(filepath): (1)
 def _syscmd_file(target, default=''): (1)
 'win32': ('', 'WindowsPE'), (1)
 'win16': ('', 'Windows'), (1)
 'dos': ('', 'MSDOS'), (1)
 _default_architecture = { (1)
 def architecture(executable=sys.executable, bits='', linkage=''): (1)
 def _get_machine_win32(): (1)
 class _Processor: (2)
 @classmethod (2)
 def get(cls): (2)
 def get_win32(): (1)
 def get_OpenVMS(): (1)
 def get_ios(): (1)
 def from_subprocess(): (1)
 def _unknown_as_blank(val): (1)
 class uname_result( (3)
 collections.namedtuple( (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = field_names.replace(',', ' ').split() (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (7)
 if type(name) is not str: (6)
 if not name.isidentifier(): (6)
 if _iskeyword(name): (6)
 seen = set() (1)
 for name in field_names: (6)
 if name.startswith('_') and not rename: (5)
 if name in seen: (5)
 seen.add(name) (5)
 field_defaults = {} (1)
 if defaults is not None: (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (7)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (6)
 doc = _sys.intern(f'Alias for field number {index}') (5)
 class_namespace[name] = _tuplegetter(index, doc) (5)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 try: (1)
 module = _sys._getframemodulename(1) or '__main__' (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 "uname_result_base", (1)
 "system node release version machine") (1)
 """ (1)
 _fields = ('system', 'node', 'release', 'version', 'machine', 'processor') (1)
 @functools.cached_property (2)
functools.py (1) self.func = func (1)
 self.attrname = None (1)
 self.__doc__ = func.__doc__ (1)
 self.__module__ = func.__module__ (1)

 def processor(self): (2)
 def __iter__(self): (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 def __getitem__(self, key): (1)
 def __len__(self): (1)
 def __reduce__(self): (1)
functools.py (1) if self.attrname is None: (1)
 self.attrname = name (1)

 _uname_cache = None (1)
 def uname(): (1)
 def system(): (1)
 def node(): (1)
 def release(): (1)
 def version(): (1)
 def machine(): (1)
 def processor(): (1)
 _sys_version_cache = {} (1)
 def _sys_version(sys_version=None): (1)
 def python_implementation(): (1)
 def python_version(): (1)
 def python_version_tuple(): (1)
 def python_branch(): (1)
 def python_revision(): (1)
 def python_build(): (1)
 def python_compiler(): (1)
 _platform_cache = {} (1)
 def platform(aliased=False, terse=False): (1)
 _os_release_candidates = ("/etc/os-release", "/usr/lib/os-release") (1)
 _os_release_cache = None (1)
 def _parse_os_release(lines): (1)
 def freedesktop_os_release(): (1)
 if __name__ == '__main__': (1)

format.py (1) __all__ = [] (1)
 drop_metadata.__module__ = "numpy.lib.format" (1)
 EXPECTED_KEYS = {'descr', 'fortran_order', 'shape'} (1)
 MAGIC_PREFIX = b'\x93NUMPY' (1)
 MAGIC_LEN = len(MAGIC_PREFIX) + 2 (1)
 ARRAY_ALIGN = 64 # plausible values are powers of 2 between 16 and 4096 (1)
 BUFFER_SIZE = 2**18  # size of buffer for reading npz files in bytes (1)
 GROWTH_AXIS_MAX_DIGITS = 21  # = len(str(8*2**64-1)) hypothetical int1 dtype (1)
 (1, 0): ('<H', 'latin1'), (1)
 (2, 0): ('<I', 'latin1'), (1)
 (3, 0): ('<I', 'utf8'), (1)
 _header_size_info = { (1)
 _MAX_HEADER_SIZE = 10000 (1)
 def _check_version(version): (1)
 def magic(major, minor): (1)
 def read_magic(fp): (1)
 def dtype_to_descr(dtype): (1)
 def descr_to_dtype(descr): (1)
 def header_data_from_array_1_0(array): (1)
 def _wrap_header(header, version): (1)
 def _wrap_header_guess_version(header): (1)
 def _write_array_header(fp, d, version=None): (1)
 def write_array_header_1_0(fp, d): (1)
 def write_array_header_2_0(fp, d): (1)
 def read_array_header_1_0(fp, max_header_size=_MAX_HEADER_SIZE): (1)
 def read_array_header_2_0(fp, max_header_size=_MAX_HEADER_SIZE): (1)
 def _filter_header(s): (1)
 def _read_array_header(fp, version, max_header_size=_MAX_HEADER_SIZE): (1)
 def write_array(fp, array, version=None, allow_pickle=True, pickle_kwargs=None): (1)
 def read_array(fp, allow_pickle=False, pickle_kwargs=None, *, (2)
 max_header_size=_MAX_HEADER_SIZE): (1)
 def open_memmap(filename, mode='r+', dtype=None, shape=None, (3)
 fortran_order=False, version=None, *, (1)
 max_header_size=_MAX_HEADER_SIZE): (1)
 def _read_bytes(fp, size, error_template="ran out of data"): (1)
 def isfileobj(f): (1)

_npyio_impl.py (2) from numpy._core import overrides (1)
 from numpy._utils import asunicode, asbytes (1)

_type_check_impl.py (1) array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 _typecodes_by_elsize = 'GDFgdfQqLlIiHhBb?' (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def mintypecode(typechars, typeset='GDFgdf', default='d'): (2)
 def _real_dispatcher(val): (1)
 @array_function_dispatch(_real_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def real(val): (2)
 def _imag_dispatcher(val): (1)
 @array_function_dispatch(_imag_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def imag(val): (2)
 def _is_type_dispatcher(x): (1)
 @array_function_dispatch(_is_type_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def iscomplex(x): (2)
 @array_function_dispatch(_is_type_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isreal(x): (2)
 @array_function_dispatch(_is_type_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def iscomplexobj(x): (2)
 @array_function_dispatch(_is_type_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isrealobj(x): (2)
 def _getmaxmin(t): (1)
 def _nan_to_num_dispatcher(x, copy=None, nan=None, posinf=None, neginf=None): (1)
 @array_function_dispatch(_nan_to_num_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None): (2)
 def _real_if_close_dispatcher(a, tol=None): (1)
 @array_function_dispatch(_real_if_close_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def real_if_close(a, tol=100): (2)
 _namefromtype = {'S1': 'character', (18)
 '?': 'bool', (1)
 'b': 'signed char', (1)
 'B': 'unsigned char', (1)
 'h': 'short', (1)
 'H': 'unsigned short', (1)
 'i': 'integer', (1)
 'I': 'unsigned integer', (1)
 'l': 'long integer', (1)
 'L': 'unsigned long integer', (1)
 'q': 'long long integer', (1)
 'Q': 'unsigned long long integer', (1)
 'f': 'single precision', (1)
 'd': 'double precision', (1)
 'g': 'long precision', (1)
 'F': 'complex single precision', (1)
 'D': 'complex double precision', (1)
 'G': 'complex long double precision', (1)
 'S': 'string', (1)
 'U': 'unicode', (1)
 'V': 'void', (1)
 'O': 'object' (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def typename(char): (2)
 array_type = [[_nx.float16, _nx.float32, _nx.float64, _nx.longdouble], (2)
 [None, _nx.complex64, _nx.complex128, _nx.clongdouble]] (1)
 array_precision = {_nx.float16: 0, (2)
 _nx.float32: 1, (1)
 _nx.float64: 2, (1)
 _nx.longdouble: 3, (1)
 _nx.complex64: 1, (1)
 _nx.complex128: 2, (1)
 _nx.clongdouble: 3} (1)
 def _common_type_dispatcher(*arrays): (1)
 @array_function_dispatch(_common_type_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def common_type(*arrays): (2)

_scimath_impl.py (1) __all__ = [ (1)
 _ln2 = nx.log(2.0) (1)
 def _tocomplex(arr): (1)
 def _fix_real_lt_zero(x): (1)
 def _fix_int_lt_zero(x): (1)
 def _fix_real_abs_gt_1(x): (1)
 def _unary_dispatcher(x): (1)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def sqrt(x): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def log(x): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def log10(x): (2)
 def _logn_dispatcher(n, x): (1)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_logn_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def logn(n, x): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def log2(x): (2)
 def _power_dispatcher(x, p): (1)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_power_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def power(x, p): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def arccos(x): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def arcsin(x): (2)
 @set_module('numpy.lib.scimath') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def arctanh(x): (2)

typing.py (2) __all__ = [ (1)
 def _type_convert(arg, module=None, *, allow_special_forms=False): (1)
 def _type_check(arg, msg, is_argument=True, module=None, *, allow_special_forms=False): (1)
 def _is_param_expr(arg): (1)
 def _should_unflatten_callable_args(typ, args): (1)
 def _type_repr(obj): (1)
 def _collect_type_parameters(args, *, enforce_default_ordering: bool = True): (1)
 def _check_generic_specialization(cls, arguments): (1)
 def _unpack_args(*args): (1)
 def _deduplicate(params, *, unhashable_fallback=False): (1)
 def _deduplicate_unhashable(unhashable_params): (1)
 def _compare_args_orderless(first_args, second_args): (1)
 def _remove_dups_flatten(parameters): (1)
 def _flatten_literal_params(parameters): (1)
 _cleanups = [] (1)
 _caches = {} (1)
 def _tp_cache(func=None, /, *, typed=False): (1)
 def _deprecation_warning_for_no_type_params_passed(funcname: str) -> None: (1)
 class _Sentinel: (2)
 __slots__ = () (1)
 def __repr__(self): (1)
 _sentinel = _Sentinel() (1)
 def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=frozenset()): (1)
 class _Final: (2)
 """Mixin to prohibit subclassing.""" (1)
 __slots__ = ('__weakref__',) (1)
 def __init_subclass__(cls, /, *args, **kwds): (1)
 class _NotIterable: (2)
 """Mixin to prevent iteration, without being compatible with Iterable. (1)
 __slots__ = () (1)
 __iter__ = None (1)
 class _SpecialForm(_Final, _NotIterable, _root=True): (2)
 __slots__ = ('_name', '__doc__', '_getitem') (1)
 def __init__(self, getitem): (1)
 def __getattr__(self, item): (1)
 def __mro_entries__(self, bases): (1)
 def __repr__(self): (1)
 def __reduce__(self): (1)
 def __call__(self, *args, **kwds): (1)
 def __or__(self, other): (1)
 def __ror__(self, other): (1)
 def __instancecheck__(self, obj): (1)
 def __subclasscheck__(self, cls): (1)
 @_tp_cache (2)
 def __getitem__(self, parameters): (2)
 def decorator(func): (7)
 if func is not None: (7)
 return decorator(func) (6)
 cache = functools.lru_cache(typed=typed)(func) (7)
functools.py (7) if isinstance(maxsize, int): (7)
 if maxsize < 0: (7)
 def decorating_function(user_function): (7)
 return decorating_function (7)
 wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo) (7)
 wrapper.cache_parameters = lambda : {'maxsize': maxsize, 'typed': typed} (7)
 return update_wrapper(wrapper, user_function) (7)
 for attr in assigned: (49)
 try: (42)
 value = getattr(wrapped, attr) (42)
 setattr(wrapper, attr, value) (42)
 for attr in updated: (14)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (7)
 wrapper.__wrapped__ = wrapped (7)
 return wrapper (7)

 _caches[func] = cache (7)
 _cleanups.append(cache.cache_clear) (7)
 del cache (7)
 @functools.wraps(func) (14)
functools.py (14) return partial(update_wrapper, wrapped=wrapped, (14)
 assigned=assigned, updated=updated) (7)
 for attr in assigned: (49)
 try: (42)
 value = getattr(wrapped, attr) (42)
 setattr(wrapper, attr, value) (42)
 for attr in updated: (14)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (7)
 wrapper.__wrapped__ = wrapped (7)
 return wrapper (7)

 def inner(*args, **kwds): (14)
 return inner (7)
 if '_root' not in kwds: (14)
 class _TypedCacheSpecialForm(_SpecialForm, _root=True): (2)
 def __getitem__(self, parameters): (1)
 class _AnyMeta(type): (2)
 def __instancecheck__(self, obj): (1)
 def __repr__(self): (1)
 class Any(metaclass=_AnyMeta): (2)
 """Special type indicating an unconstrained type. (1)
 def __new__(cls, *args, **kwargs): (1)
 @_SpecialForm (2)
 def NoReturn(self, parameters): (2)
 self._getitem = getitem (14)
 self._name = getitem.__name__ (14)
 self.__doc__ = getitem.__doc__ (14)
 @_SpecialForm (2)
 def Never(self, parameters): (2)
 @_SpecialForm (2)
 def Self(self, parameters): (2)
 @_SpecialForm (2)
 def LiteralString(self, parameters): (2)
 @_SpecialForm (2)
 def ClassVar(self, parameters): (2)
 @_SpecialForm (2)
 def Final(self, parameters): (2)
 @_SpecialForm (2)
 def Union(self, parameters): (2)
 def _make_union(left, right): (1)
 @_SpecialForm (2)
 def Optional(self, parameters): (2)
 @_TypedCacheSpecialForm (2)
 @_tp_cache(typed=True) (2)
 return decorator (1)
 def Literal(self, *parameters): (2)
 @_SpecialForm (2)
 def TypeAlias(self, parameters): (2)
 @_SpecialForm (2)
 def Concatenate(self, parameters): (2)
 @_SpecialForm (2)
 def TypeGuard(self, parameters): (2)
 @_SpecialForm (2)
 def TypeIs(self, parameters): (2)
 class ForwardRef(_Final, _root=True): (2)
 """Internal wrapper to hold a forward reference.""" (1)
 __slots__ = ('__forward_arg__', '__forward_code__', (1)
 def __init__(self, arg, is_argument=True, module=None, *, is_class=False): (1)
 def _evaluate(self, globalns, localns, type_params=_sentinel, *, recursive_guard): (1)
 def __eq__(self, other): (1)
 def __hash__(self): (1)
 def __or__(self, other): (1)
 def __ror__(self, other): (1)
 def __repr__(self): (1)
 def _is_unpacked_typevartuple(x: Any) -> bool: (1)
 def _is_typevar_like(x: Any) -> bool: (1)
 def _typevar_subst(self, arg): (1)
 def _typevartuple_prepare_subst(self, alias, args): (1)
 def _paramspec_subst(self, arg): (1)
 def _paramspec_prepare_subst(self, alias, args): (1)
 @_tp_cache (2)
 def _generic_class_getitem(cls, args): (2)
 def _generic_init_subclass(cls, *args, **kwargs): (1)
 def _is_dunder(attr): (1)
 class _BaseGenericAlias(_Final, _root=True): (2)
 """The central part of the internal API. (1)
 def __init__(self, origin, *, inst=True, name=None): (1)
 def __call__(self, *args, **kwargs): (1)
 def __mro_entries__(self, bases): (1)
 def __getattr__(self, attr): (1)
 def __setattr__(self, attr, val): (1)
 def __instancecheck__(self, obj): (1)
 def __subclasscheck__(self, cls): (1)
 def __dir__(self): (1)
 class _GenericAlias(_BaseGenericAlias, _root=True): (2)
 def __init__(self, origin, args, *, inst=True, name=None): (1)
 def __eq__(self, other): (1)
 def __hash__(self): (1)
 def __or__(self, right): (1)
 def __ror__(self, left): (1)
 @_tp_cache (2)
 def __getitem__(self, args): (2)
 def _determine_new_args(self, args): (1)
 def _make_substitution(self, args, new_arg_by_param): (1)
 def copy_with(self, args): (1)
 def __repr__(self): (1)
 def __reduce__(self): (1)
 def __mro_entries__(self, bases): (1)
 def __iter__(self): (1)
 class _SpecialGenericAlias(_NotIterable, _BaseGenericAlias, _root=True): (2)
 def __init__(self, origin, nparams, *, inst=True, name=None, defaults=()): (1)
 @_tp_cache (2)
 def __getitem__(self, params): (2)
 def copy_with(self, params): (1)
 def __repr__(self): (1)
 def __subclasscheck__(self, cls): (1)
 def __reduce__(self): (1)
 def __or__(self, right): (1)
 def __ror__(self, left): (1)
 class _DeprecatedGenericAlias(_SpecialGenericAlias, _root=True): (2)
 self, origin, nparams, *, removal_version, inst=True, name=None (1)
 def __init__( (1)
 def __instancecheck__(self, inst): (1)
 class _CallableGenericAlias(_NotIterable, _GenericAlias, _root=True): (2)
 def __repr__(self): (1)
 def __reduce__(self): (1)
 class _CallableType(_SpecialGenericAlias, _root=True): (2)
 def copy_with(self, params): (1)
 def __getitem__(self, params): (1)
 @_tp_cache (2)
 def __getitem_inner__(self, params): (2)
 class _TupleType(_SpecialGenericAlias, _root=True): (2)
 @_tp_cache (2)
 def __getitem__(self, params): (2)
 class _UnionGenericAlias(_NotIterable, _GenericAlias, _root=True): (2)
 def copy_with(self, params): (1)
 def __eq__(self, other): (1)
 def __hash__(self): (1)
 def __repr__(self): (1)
 def __instancecheck__(self, obj): (1)
 def __subclasscheck__(self, cls): (1)
 def __reduce__(self): (1)
 def _value_and_type_iter(parameters): (1)
 class _LiteralGenericAlias(_GenericAlias, _root=True): (2)
 def __eq__(self, other): (1)
 def __hash__(self): (1)
 class _ConcatenateGenericAlias(_GenericAlias, _root=True): (2)
 def copy_with(self, params): (1)
 @_SpecialForm (2)
 def Unpack(self, parameters): (2)
 class _UnpackGenericAlias(_GenericAlias, _root=True): (2)
 def __repr__(self): (1)
 def __getitem__(self, args): (1)
 @property (2)
 def __typing_unpacked_tuple_args__(self): (2)
 @property (2)
 def __typing_is_unpacked_typevartuple__(self): (2)
 class _TypingEllipsis: (2)
 """Internal placeholder for ... (ellipsis).""" (1)
 _TYPING_INTERNALS = frozenset({ (1)
 _SPECIAL_NAMES = frozenset({ (1)
 EXCLUDED_ATTRIBUTES = _TYPING_INTERNALS | _SPECIAL_NAMES | {'_MutableMapping__marker'} (1)
 def _get_protocol_attrs(cls): (1)
 def _no_init_or_replace_init(self, *args, **kwargs): (1)
 def _caller(depth=1, default='__main__'): (1)
 def _allow_reckless_class_checks(depth=2): (1)
 'collections.abc': [ (1)
 'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'], (1)
 _PROTO_ALLOWLIST = { (1)
 @functools.cache (2)
functools.py (1) return lru_cache(maxsize=None)(user_function) (1)
 if isinstance(maxsize, int): (1)
 elif callable(maxsize) and isinstance(typed, bool): (1)
 elif maxsize is not None: (1)
 def decorating_function(user_function): (1)
 return decorating_function (1)
 wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo) (1)
 wrapper.cache_parameters = lambda : {'maxsize': maxsize, 'typed': typed} (1)
 return update_wrapper(wrapper, user_function) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 def _lazy_load_getattr_static(): (2)
 _cleanups.append(_lazy_load_getattr_static.cache_clear) (1)
 def _pickle_psargs(psargs): (1)
 copyreg.pickle(ParamSpecArgs, _pickle_psargs) (1)
copyreg.py (1) if not callable(pickle_function): (1)
 dispatch_table[ob_type] = pickle_function (1)
 if constructor_ob is not None: (1)

 def _pickle_pskwargs(pskwargs): (1)
 copyreg.pickle(ParamSpecKwargs, _pickle_pskwargs) (1)
copyreg.py (1) if not callable(pickle_function): (1)
 dispatch_table[ob_type] = pickle_function (1)
 if constructor_ob is not None: (1)

 del _pickle_psargs, _pickle_pskwargs (1)
 _abc_instancecheck = ABCMeta.__instancecheck__ (1)
 _abc_subclasscheck = ABCMeta.__subclasscheck__ (1)
 def _type_check_issubclass_arg_1(arg): (1)
 class _ProtocolMeta(ABCMeta): (2)
 def __new__(mcls, name, bases, namespace, /, **kwargs): (1)
 def __init__(cls, *args, **kwargs): (1)
 def __subclasscheck__(cls, other): (1)
 def __instancecheck__(cls, instance): (1)
 @classmethod (2)
 def _proto_hook(cls, other): (2)
 class Protocol(Generic, metaclass=_ProtocolMeta): (2)
 """Base class for protocol classes. (1)
 __slots__ = () (1)
 _is_protocol = True (1)
 _is_runtime_protocol = False (1)
 def __init_subclass__(cls, *args, **kwargs): (1)
 if name == "Protocol" and bases == (Generic,): (1)
 pass (1)
 return super().__new__(mcls, name, bases, namespace, **kwargs) (1)
<frozen abc> (1) (1)

 if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)
_linalg.py (1) from numpy._utils import set_module (1)


_linalg.py (1) from numpy.lib.array_utils import normalize_axis_index, normalize_axis_tuple (1)
 from numpy.linalg import _umath_linalg (1)

_function_base_impl.py (1) array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 __all__ = [ (1)
 _QuantileMethods = dict( (2)
 inverted_cdf=dict( (2)
 get_virtual_index=lambda n, quantiles: _inverted_cdf(n, quantiles), (1)
 fix_gamma=None,  # should never be called (1)
 averaged_inverted_cdf=dict( (2)
 get_virtual_index=lambda n, quantiles: (n * quantiles) - 1, (1)
 fix_gamma=lambda gamma, _: _get_gamma_mask( (1)
 closest_observation=dict( (2)
 get_virtual_index=lambda n, quantiles: _closest_observation(n, (1)
 fix_gamma=None,  # should never be called (1)
 interpolated_inverted_cdf=dict( (2)
 get_virtual_index=lambda n, quantiles: (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 hazen=dict( (2)
 get_virtual_index=lambda n, quantiles: (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 weibull=dict( (2)
 get_virtual_index=lambda n, quantiles: (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 linear=dict( (2)
 get_virtual_index=lambda n, quantiles: (n - 1) * quantiles, (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 median_unbiased=dict( (2)
 get_virtual_index=lambda n, quantiles: (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 normal_unbiased=dict( (2)
 get_virtual_index=lambda n, quantiles: (1)
 fix_gamma=lambda gamma, _: gamma, (1)
 lower=dict( (2)
 get_virtual_index=lambda n, quantiles: np.floor( (1)
 fix_gamma=None,  # should never be called, index dtype is int (1)
 higher=dict( (2)
 get_virtual_index=lambda n, quantiles: np.ceil( (1)
 fix_gamma=None,  # should never be called, index dtype is int (1)
 midpoint=dict( (2)
 get_virtual_index=lambda n, quantiles: 0.5 * ( (1)
 fix_gamma=lambda gamma, index: _get_gamma_mask( (1)
 nearest=dict( (2)
 get_virtual_index=lambda n, quantiles: np.around( (1)
 fix_gamma=None, (1)
 def _rot90_dispatcher(m, k=None, axes=None): (1)
 @array_function_dispatch(_rot90_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def rot90(m, k=1, axes=(0, 1)): (2)
 def _flip_dispatcher(m, axis=None): (1)
 @array_function_dispatch(_flip_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def flip(m, axis=None): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def iterable(y): (2)
 def _weights_are_valid(weights, a, axis): (1)
 def _average_dispatcher(a, axis=None, weights=None, returned=None, *, (2)
 keepdims=None): (1)
 @array_function_dispatch(_average_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def average(a, axis=None, weights=None, returned=False, *, (3)
 keepdims=np._NoValue): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def asarray_chkfinite(a, dtype=None, order=None): (2)
 def _piecewise_dispatcher(x, condlist, funclist, *args, **kw): (1)
 @array_function_dispatch(_piecewise_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def piecewise(x, condlist, funclist, *args, **kw): (2)
 def _select_dispatcher(condlist, choicelist, default=None): (1)
 @array_function_dispatch(_select_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def select(condlist, choicelist, default=0): (2)
 def _copy_dispatcher(a, order=None, subok=None): (1)
 @array_function_dispatch(_copy_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def copy(a, order='K', subok=False): (2)
 def _gradient_dispatcher(f, *varargs, axis=None, edge_order=None): (1)
 @array_function_dispatch(_gradient_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def gradient(f, *varargs, axis=None, edge_order=1): (2)
 def _diff_dispatcher(a, n=None, axis=None, prepend=None, append=None): (1)
 @array_function_dispatch(_diff_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue): (2)
 def _interp_dispatcher(x, xp, fp, left=None, right=None, period=None): (1)
 @array_function_dispatch(_interp_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def interp(x, xp, fp, left=None, right=None, period=None): (2)
 def _angle_dispatcher(z, deg=None): (1)
 @array_function_dispatch(_angle_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def angle(z, deg=False): (2)
 def _unwrap_dispatcher(p, discont=None, axis=None, *, period=None): (1)
 @array_function_dispatch(_unwrap_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unwrap(p, discont=None, axis=-1, *, period=2*pi): (2)
 def _sort_complex(a): (1)
 @array_function_dispatch(_sort_complex) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def sort_complex(a): (2)
 def _arg_trim_zeros(filt): (1)
 def _trim_zeros(filt, trim=None, axis=None): (1)
 @array_function_dispatch(_trim_zeros) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def trim_zeros(filt, trim='fb', axis=None): (2)
 def _extract_dispatcher(condition, arr): (1)
 @array_function_dispatch(_extract_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def extract(condition, arr): (2)
 def _place_dispatcher(arr, mask, vals): (1)
 @array_function_dispatch(_place_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def place(arr, mask, vals): (2)
 def disp(mesg, device=None, linefeed=True): (1)
 _DIMENSION_NAME = r'\w+' (1)
 _CORE_DIMENSION_LIST = '(?:{0:}(?:,{0:})*)?'.format(_DIMENSION_NAME) (1)
 _ARGUMENT = r'\({}\)'.format(_CORE_DIMENSION_LIST) (1)
 _ARGUMENT_LIST = '{0:}(?:,{0:})*'.format(_ARGUMENT) (1)
 _SIGNATURE = '^{0:}->{0:}$'.format(_ARGUMENT_LIST) (1)
 def _parse_gufunc_signature(signature): (1)
 def _update_dim_sizes(dim_sizes, arg, core_dims): (1)
 def _parse_input_dimensions(args, input_core_dims): (1)
 def _calculate_shapes(broadcast_shape, dim_sizes, list_of_core_dims): (1)
 results=None): (1)
 def _create_arrays(broadcast_shape, dim_sizes, list_of_core_dims, dtypes, (1)
 def _get_vectorize_dtype(dtype): (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class vectorize: (2)
 """ (1)
 def __init__(self, pyfunc=np._NoValue, otypes=None, doc=None, (2)
 excluded=None, cache=False, signature=None): (1)
 def _init_stage_2(self, pyfunc, *args, **kwargs): (1)
 def _call_as_normal(self, *args, **kwargs): (1)
 def __call__(self, *args, **kwargs): (1)
 def _get_ufunc_and_otypes(self, func, args): (1)
 def _vectorize_call(self, func, args): (1)
 def _vectorize_call_with_signature(self, func, args): (1)
 def _cov_dispatcher(m, y=None, rowvar=None, bias=None, ddof=None, (3)
 fweights=None, aweights=None, *, dtype=None): (2)
 @array_function_dispatch(_cov_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, (4)
 aweights=None, *, dtype=None): (2)
 def _corrcoef_dispatcher(x, y=None, rowvar=None, bias=None, ddof=None, *, (2)
 dtype=None): (1)
 @array_function_dispatch(_corrcoef_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, ddof=np._NoValue, *, (3)
 dtype=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def blackman(M): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def bartlett(M): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def hanning(M): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def hamming(M): (2)
 _i0A = [ (1)
 _i0B = [ (1)
 def _chbevl(x, vals): (1)
 def _i0_1(x): (1)
 def _i0_2(x): (1)
 def _i0_dispatcher(x): (1)
 @array_function_dispatch(_i0_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def i0(x): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def kaiser(M, beta): (2)
 def _sinc_dispatcher(x): (1)
 @array_function_dispatch(_sinc_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def sinc(x): (2)
 def _ureduce(a, func, keepdims=False, **kwargs): (1)
 a, axis=None, out=None, overwrite_input=None, keepdims=None): (1)
 def _median_dispatcher( (1)
 @array_function_dispatch(_median_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def median(a, axis=None, out=None, overwrite_input=False, keepdims=False): (2)
 def _median(a, axis=None, out=None, overwrite_input=False): (1)
 def _percentile_dispatcher(a, q, axis=None, out=None, overwrite_input=None, (3)
 method=None, keepdims=None, *, weights=None, (2)
 interpolation=None): (1)
 @array_function_dispatch(_percentile_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=False, (1)
 def percentile(a, (3)
 weights=None, (1)
 interpolation=None): (1)
 def _quantile_dispatcher(a, q, axis=None, out=None, overwrite_input=None, (3)
 method=None, keepdims=None, *, weights=None, (2)
 interpolation=None): (1)
 @array_function_dispatch(_quantile_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=False, (1)
 def quantile(a, (3)
 weights=None, (1)
 interpolation=None): (1)
 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=False, (1)
 weights=None): (1)
 def _quantile_unchecked(a, (1)
 def _quantile_is_valid(q): (1)
 def _check_interpolation_as_method(method, interpolation, fname): (1)
 def _compute_virtual_index(n, quantiles, alpha: float, beta: float): (1)
 def _get_gamma(virtual_indexes, previous_indexes, method): (1)
 def _lerp(a, b, t, out=None): (1)
 def _get_gamma_mask(shape, default_value, conditioned_value, where): (1)
 def _discrete_interpolation_to_boundaries(index, gamma_condition_fun): (1)
 def _closest_observation(n, quantiles): (1)
 def _inverted_cdf(n, quantiles): (1)
 axis: int | None = None, (2)
 out=None, (1)
 overwrite_input: bool = False, (2)
 method="linear", (1)
 def _quantile_ureduce_func( (7)
 a: np.array, (1)
 q: np.array, (1)
 weights: np.array, (1)
 ) -> np.array: (1)
 def _get_indexes(arr, virtual_indexes, valid_values_count): (1)
 axis: int = -1, (2)
 method="linear", (1)
 out=None, (1)
 weights=None, (1)
 def _quantile( (4)
 arr: np.array, (1)
 quantiles: np.array, (1)
 def _trapezoid_dispatcher(y, x=None, dx=None, axis=None): (1)
 @array_function_dispatch(_trapezoid_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def trapezoid(y, x=None, dx=1.0, axis=-1): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def trapz(y, x=None, dx=1.0, axis=-1): (2)
 def _meshgrid_dispatcher(*xi, copy=None, sparse=None, indexing=None): (1)
 @array_function_dispatch(_meshgrid_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def meshgrid(*xi, copy=True, sparse=False, indexing='xy'): (2)
 def _delete_dispatcher(arr, obj, axis=None): (1)
 @array_function_dispatch(_delete_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def delete(arr, obj, axis=None): (2)
 def _insert_dispatcher(arr, obj, values, axis=None): (1)
 @array_function_dispatch(_insert_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def insert(arr, obj, values, axis=None): (2)
 def _append_dispatcher(arr, values, axis=None): (1)
 @array_function_dispatch(_append_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def append(arr, values, axis=None): (2)
 def _digitize_dispatcher(x, bins, right=None): (1)
 @array_function_dispatch(_digitize_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def digitize(x, bins, right=False): (2)

_index_tricks_impl.py (1) array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 __all__ = [ (1)
 def _ix__dispatcher(*args): (1)
 @array_function_dispatch(_ix__dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ix_(*args): (2)
 class nd_grid: (2)
 """ (1)
 __slots__ = ('sparse',) (1)
 def __init__(self, sparse=False): (1)
 def __getitem__(self, key): (1)
 class MGridClass(nd_grid): (2)
 """ (1)
 __slots__ = () (1)
 def __init__(self): (1)
 mgrid = MGridClass() (1)
 super().__init__(sparse=False) (1)
 self.sparse = sparse (2)
 class OGridClass(nd_grid): (2)
 """ (1)
 __slots__ = () (1)
 def __init__(self): (1)
 ogrid = OGridClass() (1)
 super().__init__(sparse=True) (1)
 class AxisConcatenator: (2)
 """ (1)
 __slots__ = ('axis', 'matrix', 'trans1d', 'ndmin') (1)
 concatenate = staticmethod(_nx.concatenate) (1)
 makemat = staticmethod(matrixlib.matrix) (1)
 def __init__(self, axis=0, matrix=False, ndmin=1, trans1d=-1): (1)
 def __getitem__(self, key): (1)
 def __len__(self): (1)
 class RClass(AxisConcatenator): (2)
 """ (1)
 __slots__ = () (1)
 def __init__(self): (1)
 r_ = RClass() (1)
 AxisConcatenator.__init__(self, 0) (1)
 self.axis = axis (2)
 self.matrix = matrix (2)
 self.trans1d = trans1d (2)
 self.ndmin = ndmin (2)
 class CClass(AxisConcatenator): (2)
 """ (1)
 __slots__ = () (1)
 def __init__(self): (1)
 c_ = CClass() (1)
 AxisConcatenator.__init__(self, -1, ndmin=2, trans1d=0) (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class ndenumerate: (2)
 """ (1)
 def __init__(self, arr): (1)
 def __next__(self): (1)
 def __iter__(self): (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class ndindex: (2)
 """ (1)
 def __init__(self, *shape): (1)
 def __iter__(self): (1)
 def ndincr(self): (1)
 def __next__(self): (1)
 class IndexExpression: (2)
 """ (1)
 __slots__ = ('maketuple',) (1)
 def __init__(self, maketuple): (1)
 def __getitem__(self, item): (1)
 index_exp = IndexExpression(maketuple=True) (1)
 self.maketuple = maketuple (2)
 s_ = IndexExpression(maketuple=False) (1)
 def _fill_diagonal_dispatcher(a, val, wrap=None): (1)
 @array_function_dispatch(_fill_diagonal_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def fill_diagonal(a, val, wrap=False): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def diag_indices(n, ndim=2): (2)
 def _diag_indices_from(arr): (1)
 @array_function_dispatch(_diag_indices_from) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diag_indices_from(arr): (2)

 (826)
 (621)
 (621)
 (621)
 (205)
_globals.py (1) __all__ = ['_NoValue', '_CopyMode'] (1)
 if '_is_loaded' in globals(): (1)
 _is_loaded = True (1)
 class _NoValueType: (2)
 """Special keyword value. (1)
 __instance = None (1)
 def __new__(cls): (1)
 def __repr__(self): (1)
 _NoValue = _NoValueType() (1)
 if not cls.__instance: (1)
 cls.__instance = super().__new__(cls) (1)
 return cls.__instance (1)
 @_set_module("numpy") (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
enum.py (1) member_map = cls.__dict__.get('_member_map_', {}) (1)
 if name in member_map: (1)
 super().__setattr__(name, value) (1)

 return func (1)

enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (3)
 def _is_private(cls_name, name): (3)
 pattern = '_%s__' % (cls_name, ) (3)
 pat_len = len(pattern) (3)
 len(name) > pat_len (3)
 return False (3)
 elif _is_sunder(key): (3)
 len(name) > 2 and (9)
 name[0] == name[-1] == '_' and (3)
 name[1] != '_' and (3)
 return ( (3)
 elif _is_dunder(key): (3)
 len(name) > 4 and (9)
 name[:2] == name[-2:] == '__' and (3)
 name[2] != '_' and (3)
 name[-3] != '_' (3)
 return ( (3)
 if key == '__order__': (3)
 super().__setitem__(key, value) (3)
 and name.startswith(pattern) (1)

 class _CopyMode(enum.Enum): (2)
enum.py (1) metacls._check_for_existing_members_(cls, bases) (1)
 for chain in bases: (2)
 for base in chain.__mro__: (3)
 if isinstance(base, EnumType) and base._member_names_: (2)
 enum_dict = EnumDict(cls) (1)
 super().__init__() (1)
 self._member_names = {} # use a dict -- faster look-up than a list, and keeps insertion order since 3.7 (1)
 self._last_values = [] (1)
 self._ignore = [] (1)
 self._auto_called = False (1)
 self._cls_name = cls_name (1)
 member_type, first_enum = metacls._get_mixins_(cls, bases) (1)
 if not bases: (1)
 first_enum = bases[-1] (1)
 if not isinstance(first_enum, EnumType): (1)
 member_type = mcls._find_data_type_(class_name, bases) or object (1)
 data_types = set() (1)
 base_chain = set() (1)
 for chain in bases: (2)
 candidate = None (1)
 for base in chain.__mro__: (3)
 base_chain.add(base) (2)
 if base is object: (2)
 elif isinstance(base, EnumType): (1)
 if base._member_type_ is not object: (1)
 continue (1)
 if len(data_types) > 1: (1)
 elif data_types: (1)
 return None (1)
 return member_type, first_enum (1)
 if first_enum is not None: (1)
 enum_dict['_generate_next_value_'] = getattr( (2)
 first_enum, '_generate_next_value_', None, (1)
 if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 and name.startswith(pattern) (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (3)
 name[0] == name[-1] == '_' and (1)
 name[1] != '_' and (1)
 name[-2] != '_' (1)
 return ( (1)
 if key not in ( (1)
 if key == '_generate_next_value_': (1)
 if self._auto_called: (1)
 _gnv = value.__func__ if isinstance(value, staticmethod) else value (1)
 setattr(self, '_generate_next_value', _gnv) (1)
 super().__setitem__(key, value) (1)
 return enum_dict (1)

 """ (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (3)
 name[0] == name[-1] == '_' and (1)
 name[1] != '_' and (1)
 return ( (1)
 elif _is_dunder(key): (1)
 len(name) > 4 and (3)
 name[:2] == name[-2:] == '__' and (1)
 name[2] != '_' and (1)
 name[-3] != '_' (1)
 return ( (1)
 if key == '__order__': (1)
 super().__setitem__(key, value) (1)

 ALWAYS = True (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (2)
 name[0] == name[-1] == '_' and (1)
 return ( (1)
 elif _is_dunder(key): (1)
 len(name) > 4 and (2)
 name[:2] == name[-2:] == '__' and (1)
 return ( (1)
 elif key in self._member_names: (1)
 elif key in self._ignore: (1)
 elif isinstance(value, nonmember): (1)
 elif isinstance(value, partial): (1)
 elif _is_descriptor(value): (1)
 return not isinstance(obj, partial) and ( (2)
 hasattr(obj, '__get__') or (2)
 hasattr(obj, '__set__') or (1)
 hasattr(obj, '__delete__') (1)
 elif self._cls_name is not None and _is_internal_class(self._cls_name, value): (1)
 if not isinstance(obj, type): (1)
 return False (1)
 if key in self: (1)
 elif isinstance(value, member): (1)
 non_auto_store = True (1)
 single = False (1)
 if isinstance(value, auto): (1)
 if isinstance(value, tuple) and any(isinstance(v, auto) for v in value): (1)
 self._member_names[key] = None (1)
 if non_auto_store: (1)
 self._last_values.append(value) (1)
 super().__setitem__(key, value) (1)

 NEVER = False (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (2)
 name[0] == name[-1] == '_' and (1)
 return ( (1)
 elif _is_dunder(key): (1)
 len(name) > 4 and (2)
 name[:2] == name[-2:] == '__' and (1)
 return ( (1)
 elif key in self._member_names: (1)
 elif key in self._ignore: (1)
 elif isinstance(value, nonmember): (1)
 elif isinstance(value, partial): (1)
 elif _is_descriptor(value): (1)
 return not isinstance(obj, partial) and ( (2)
 hasattr(obj, '__get__') or (2)
 hasattr(obj, '__set__') or (1)
 hasattr(obj, '__delete__') (1)
 elif self._cls_name is not None and _is_internal_class(self._cls_name, value): (1)
 if not isinstance(obj, type): (1)
 return False (1)
 if key in self: (1)
 elif isinstance(value, member): (1)
 non_auto_store = True (1)
 single = False (1)
 if isinstance(value, auto): (1)
 if isinstance(value, tuple) and any(isinstance(v, auto) for v in value): (1)
 self._member_names[key] = None (1)
 if non_auto_store: (1)
 self._last_values.append(value) (1)
 super().__setitem__(key, value) (1)

 IF_NEEDED = 2 (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (1)
 def _is_private(cls_name, name): (1)
 pattern = '_%s__' % (cls_name, ) (1)
 pat_len = len(pattern) (1)
 len(name) > pat_len (1)
 return False (1)
 elif _is_sunder(key): (1)
 len(name) > 2 and (2)
 name[0] == name[-1] == '_' and (1)
 return ( (1)
 elif _is_dunder(key): (1)
 len(name) > 4 and (2)
 name[:2] == name[-2:] == '__' and (1)
 return ( (1)
 elif key in self._member_names: (1)
 elif key in self._ignore: (1)
 elif isinstance(value, nonmember): (1)
 elif isinstance(value, partial): (1)
 elif _is_descriptor(value): (1)
 return not isinstance(obj, partial) and ( (2)
 hasattr(obj, '__get__') or (2)
 hasattr(obj, '__set__') or (1)
 hasattr(obj, '__delete__') (1)
 elif self._cls_name is not None and _is_internal_class(self._cls_name, value): (1)
 if not isinstance(obj, type): (1)
 return False (1)
 if key in self: (1)
 elif isinstance(value, member): (1)
 non_auto_store = True (1)
 single = False (1)
 if isinstance(value, auto): (1)
 if isinstance(value, tuple) and any(isinstance(v, auto) for v in value): (1)
 self._member_names[key] = None (1)
 if non_auto_store: (1)
 self._last_values.append(value) (1)
 super().__setitem__(key, value) (1)

 def __bool__(self): (1)
enum.py (1) if self._cls_name is not None and _is_private(self._cls_name, key): (2)
 def _is_private(cls_name, name): (2)
 pattern = '_%s__' % (cls_name, ) (2)
 pat_len = len(pattern) (2)
 len(name) > pat_len (2)
 return False (2)
 elif _is_sunder(key): (2)
 len(name) > 2 and (6)
 name[0] == name[-1] == '_' and (2)
 name[1] != '_' and (2)
 return ( (2)
 elif _is_dunder(key): (2)
 len(name) > 4 and (6)
 name[:2] == name[-2:] == '__' and (2)
 name[2] != '_' and (2)
 name[-3] != '_' (2)
 return ( (2)
 if key == '__order__': (2)
 super().__setitem__(key, value) (2)
 and name.startswith(pattern) (1)
 if _simple: (1)
 classdict.setdefault('_ignore_', []).append('_ignore_') (1)
 ignore = classdict['_ignore_'] (1)
 for key in ignore: (2)
 classdict.pop(key, None) (1)
 member_names = classdict._member_names (1)
 invalid_names = set(member_names) & {'mro', ''} (1)
 if invalid_names: (1)
 _order_ = classdict.pop('_order_', None) (1)
 _gnv = classdict.get('_generate_next_value_') (1)
 if _gnv is not None and type(_gnv) is not staticmethod: (1)
 _gnv = staticmethod(_gnv) (1)
 classdict = dict(classdict.items()) (1)
 if _gnv is not None: (1)
 classdict['_generate_next_value_'] = _gnv (1)
 member_type, first_enum = metacls._get_mixins_(cls, bases) (1)
 if not bases: (1)
 first_enum = bases[-1] (1)
 if not isinstance(first_enum, EnumType): (1)
 member_type = mcls._find_data_type_(class_name, bases) or object (1)
 data_types = set() (1)
 base_chain = set() (1)
 for chain in bases: (2)
 candidate = None (1)
 for base in chain.__mro__: (3)
 base_chain.add(base) (2)
 if base is object: (2)
 elif isinstance(base, EnumType): (1)
 if base._member_type_ is not object: (1)
 continue (1)
 if len(data_types) > 1: (1)
 elif data_types: (1)
 return None (1)
 return member_type, first_enum (1)
 __new__, save_new, use_args = metacls._find_new_( (2)
 classdict, member_type, first_enum, (1)
 __new__ = classdict.get('__new__', None) (1)
 save_new = first_enum is not None and __new__ is not None (1)
 if __new__ is None: (1)
 for method in ('__new_member__', '__new__'): (3)
 for possible in (member_type, first_enum): (6)
 target = getattr(possible, method, None) (4)
 if target not in { (8)
 None, (4)
 None.__new__, (4)
 object.__new__, (4)
 Enum.__new__, (4)
 if __new__ is not None: (2)
 __new__ = object.__new__ (1)
 if first_enum is None or __new__ in (Enum.__new__, object.__new__): (1)
 use_args = False (1)
 return __new__, save_new, use_args (1)
 classdict['_new_member_'] = __new__ (1)
 classdict['_use_args_'] = use_args (1)
 for name in member_names: (4)
 value = classdict[name] (3)
 classdict[name] = _proto_member(value) (3)
 self.value = value (3)
 classdict['_member_names_'] = [] (1)
 classdict['_member_map_'] = {} (1)
 classdict['_value2member_map_'] = {} (1)
 classdict['_hashable_values_'] = []          # for comparing with non-hashable types (1)
 classdict['_unhashable_values_'] = []       # e.g. frozenset() with set() (1)
 classdict['_unhashable_values_map_'] = {} (1)
 classdict['_member_type_'] = member_type (1)
 classdict['_value_repr_'] = metacls._find_data_repr_(cls, bases) (1)
 for chain in bases: (1)
 for base in chain.__mro__: (1)
 if base is object: (1)
 elif isinstance(base, EnumType): (1)
 return base._value_repr_ (1)
 boundary (1)
 or getattr(first_enum, '_boundary_', None) (1)
 classdict['_boundary_'] = ( (1)
 classdict['_flag_mask_'] = 0 (1)
 classdict['_singles_mask_'] = 0 (1)
 classdict['_all_bits_'] = 0 (1)
 classdict['_inverted_'] = None (1)
 try: (1)
 classdict['_%s__in_progress' % cls] = True (1)
 enum_class = super().__new__(metacls, cls, bases, classdict, **kwds) (1)
 delattr(enum_class, member_name) (3)
 if attr in cls._member_map_: (9)
 super().__delattr__(attr) (9)
 value = self.value (3)
 if not isinstance(value, tuple): (3)
 args = (value, ) (3)
 if enum_class._member_type_ is tuple:   # special case for tuple enums (3)
 if not enum_class._use_args_: (3)
 enum_member = enum_class._new_member_(enum_class) (3)
 if not hasattr(enum_member, '_value_'): (3)
 if enum_class._member_type_ is object: (3)
 enum_member._value_ = value (3)
 value = enum_member._value_ (3)
 enum_member._name_ = member_name (3)
 enum_member.__objclass__ = enum_class (3)
 enum_member.__init__(*args) (3)
 pass (3)
 enum_member._sort_order_ = len(enum_class._member_names_) (3)
 if Flag is not None and issubclass(enum_class, Flag): (3)
 try: (3)
 try: (3)
 enum_member = enum_class._value2member_map_[value] (3)
 except TypeError: (3)
 except KeyError: (3)
 Flag is None (3)
 or not issubclass(enum_class, Flag) (3)
 enum_class._member_names_.append(member_name) (3)
 enum_class._add_member_(member_name, enum_member) (3)
 if name in cls._member_map_: (3)
 found_descriptor = None (3)
 descriptor_type = None (3)
 class_type = None (3)
 for base in cls.__mro__[1:]: (9)
 attr = base.__dict__.get(name) (6)
 if attr is not None: (6)
 if found_descriptor: (3)
 setattr(cls, name, member) (3)
 member_map = cls.__dict__.get('_member_map_', {}) (4)
 if name in member_map: (4)
 super().__setattr__(name, value) (4)
 cls._member_map_[name] = member (3)
 try: (3)
 enum_class._value2member_map_.setdefault(value, enum_member) (3)
 if value not in enum_class._hashable_values_: (3)
 enum_class._hashable_values_.append(value) (3)
 classdict['_%s__in_progress' % cls] = False (1)
 delattr(enum_class, '_%s__in_progress' % cls) (1)
 classdict.update(enum_class.__dict__) (1)
 if ReprEnum is not None and ReprEnum in bases: (1)
 for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'): (5)
 if name not in classdict: (4)
 enum_method = getattr(first_enum, name) (4)
 found_method = getattr(enum_class, name) (4)
 object_method = getattr(object, name) (4)
 data_type_method = getattr(member_type, name) (4)
 if found_method in (data_type_method, object_method): (4)
 if Flag is not None and issubclass(enum_class, Flag): (1)
 if Enum is not None: (1)
 if save_new: (1)
 enum_class.__new__ = Enum.__new__ (1)
 if _order_ is not None: (1)
 Flag is None and cls != 'Flag' (1)
 or Flag is not None and not issubclass(enum_class, Flag) (1)
 delattr(enum_class, '_boundary_') (1)
 delattr(enum_class, '_flag_mask_') (1)
 delattr(enum_class, '_singles_mask_') (1)
 delattr(enum_class, '_all_bits_') (1)
 delattr(enum_class, '_inverted_') (1)
 if _order_: (1)
 return enum_class (1)


__init__.py (49) from .version import __version__ (2)
 try: (2)
 from numpy.__config__ import show_config (2)
 for envkey in env_added: (3)
 del os.environ[envkey] (2)
<frozen os> (2) (2)
 (2)
 (2)
 (2)
 (2)
 (2)
 (2)

 del envkey (1)
 del env_added (1)
 del os (1)
 from . import umath (1)
 if not (hasattr(multiarray, '_multiarray_umath') and (1)
 hasattr(umath, '_multiarray_umath')): (1)
 from . import numerictypes as nt (1)
 from .numerictypes import sctypes, sctypeDict (1)
 from .numeric import * (1)
 from .fromnumeric import * (1)
 from .function_base import * (1)
 from . import getlimits (1)
 from .getlimits import * (1)
 from .shape_base import * (1)
 from .einsumfunc import * (2)
 from . import _add_newdocs_scalars (1)
 from . import _dtype_ctypes (1)
 from . import _internal (1)
 from . import _dtype (1)
 from . import _methods (1)
 acos = numeric.arccos (1)
 acosh = numeric.arccosh (1)
 asin = numeric.arcsin (1)
 asinh = numeric.arcsinh (1)
 atan = numeric.arctan (1)
 atanh = numeric.arctanh (1)
 atan2 = numeric.arctan2 (1)
 bitwise_left_shift = numeric.left_shift (1)
 bitwise_invert = numeric.invert (1)
 bitwise_right_shift = numeric.right_shift (1)
 permute_dims = numeric.transpose (1)
 pow = numeric.power (1)
 __all__ = [ (1)
 __all__ += numeric.__all__ (1)
 __all__ += function_base.__all__ (1)
 __all__ += getlimits.__all__ (1)
 def _ufunc_reduce(func): (1)
 def _DType_reconstruct(scalar_type): (1)
 def _DType_reduce(DType): (1)
 def __getattr__(name): (1)
 import copyreg (1)
 copyreg.pickle(ufunc, _ufunc_reduce) (1)
copyreg.py (1) if not callable(pickle_function): (1)
 dispatch_table[ob_type] = pickle_function (1)
 if constructor_ob is not None: (1)

 copyreg.pickle(type(dtype), _DType_reduce, _DType_reconstruct) (1)
copyreg.py (1) if not callable(pickle_function): (1)
 dispatch_table[ob_type] = pickle_function (1)
 if constructor_ob is not None: (1)
 constructor(constructor_ob) (1)
 if not callable(object): (1)

 del copyreg, _ufunc_reduce, _DType_reduce (1)
 from numpy._pytesttester import PytestTester (1)
 from ._core import ( (1)
 for ta in ["float96", "float128", "complex192", "complex256"]: (5)
 try: (4)
 globals()[ta] = getattr(_core, ta) (4)
 if name == "MachAr": (4)
 raise AttributeError(f"Module {__name__!r} has no attribute {name!r}") (4)
 except AttributeError: (4)
 pass (4)
 del ta (1)
 from . import lib (1)
 from . import introspect (1)
 from . import mixins (1)
 from . import npyio (1)
 from . import scimath (1)
 from . import stride_tricks (1)
 from . import _type_check_impl (1)
 from . import _index_tricks_impl (1)
 from . import _linalg (1)
 from .defmatrix import * (1)
 from . import _nanfunctions_impl (1)
 from . import _function_base_impl (1)
 from . import _stride_tricks_impl (1)
 from . import _shape_base_impl (1)
 from . import _twodim_base_impl (1)
 from . import _ufunclike_impl (1)
 from . import _histograms_impl (1)
 from . import _utils_impl (1)
 from . import _arraysetops_impl (1)
 from . import _polynomial_impl (1)
 from . import _npyio_impl (1)
 from . import _arrayterator_impl (1)
 from . import _arraypad_impl (1)
 from . import _version (1)
 from ._arrayterator_impl import Arrayterator (1)
 from .lib import scimath as emath (1)
 from .lib._histograms_impl import ( (1)
 from .matrixlib import ( (1)
 __numpy_submodules__ = { (1)
 "module 'numpy' has no attribute '{n}'.\n" (1)
 _msg = ( (1)
 "If you specifically wanted the numpy scalar type, use `np.{}` here.") (1)
 _specific_msg = ( (1)
 "When replacing `np.{}`, you may wish to use e.g. `np.int64` " (1)
 _int_extended_msg = ( (1)
 ("object", ""),  # The NumPy scalar only exists by name. (1)
 ("float", _specific_msg.format("float64")), (1)
 ("complex", _specific_msg.format("complex128")), (1)
 ("str", _specific_msg.format("str_")), (1)
 ("int", _int_extended_msg.format("int"))] (1)
 _type_info = [ (1)
 for n, extended_msg in _type_info (7)
 __former_attrs__ = { (2)
 n: _msg.format(n=n, extended_msg=extended_msg) (5)
 __future_scalars__ = {"str", "bytes", "object"} (1)
 __array_api_version__ = "2023.12" (1)
 from ._array_api_info import __array_namespace_info__ (1)

overrides.py (1) from .._utils._inspect import getargspec (1)

_exceptions.py (1) def _unpack_tuple(tup): (1)
 def _display_as_base(cls): (1)
 class UFuncTypeError(TypeError): (2)
 """ Base class for all ufunc exceptions """ (1)
 def __init__(self, ufunc): (1)
 @_display_as_base (3)
 class _UFuncNoLoopError(UFuncTypeError): (2)
 """ Thrown when a ufunc loop cannot be found """ (1)
 def __init__(self, ufunc, dtypes): (1)
 def __str__(self): (1)
 assert issubclass(cls, Exception) (6)
 cls.__name__ = cls.__base__.__name__ (6)
 return cls (6)
 @_display_as_base (3)
 class _UFuncBinaryResolutionError(_UFuncNoLoopError): (2)
 """ Thrown when a binary resolution fails """ (1)
 def __init__(self, ufunc, dtypes): (1)
 def __str__(self): (1)
 @_display_as_base (3)
 class _UFuncCastingError(UFuncTypeError): (2)
 def __init__(self, ufunc, casting, from_, to): (1)
 @_display_as_base (3)
 class _UFuncInputCastingError(_UFuncCastingError): (2)
 """ Thrown when a ufunc input cannot be casted """ (1)
 def __init__(self, ufunc, casting, from_, to, i): (1)
 def __str__(self): (1)
 @_display_as_base (3)
 class _UFuncOutputCastingError(_UFuncCastingError): (2)
 """ Thrown when a ufunc output cannot be casted """ (1)
 def __init__(self, ufunc, casting, from_, to, i): (1)
 def __str__(self): (1)
 @_display_as_base (3)
 class _ArrayMemoryError(MemoryError): (2)
 """ Thrown when an array cannot be allocated""" (1)
 def __init__(self, shape, dtype): (1)
 @property (2)
 def _total_size(self): (2)
 @staticmethod (2)
 def _size_to_string(num_bytes): (2)
 def __str__(self): (1)

dtypes.py (25) setattr(dtypes, DType.__name__, DType) (25)
 __all__.append(DType.__name__) (25)
 if alias: (25)
<frozen importlib._bootstrap_external> (1) (2)
 (1)

 from numpy import dtypes (24)
 alias = alias.removeprefix("numpy.dtypes.") (8)
 setattr(dtypes, alias, DType) (8)
 __all__.append(alias) (8)

multiarray.py (2) from . import _multiarray_umath (1)
 from ._multiarray_umath import *  # noqa: F403 (1)

umath.py (1) from ._multiarray_umath import *  # noqa: F403 (1)

numerictypes.py (2) from .multiarray import ( (1)
 __all__ = [ (1)
 from ._string_helpers import (  # noqa: F401 (1)

numeric.py (10) from . import numerictypes as nt (1)
 from .multiarray import ( (1)
 from . import umath (1)
 from . import shape_base (1)
 from .overrides import finalize_array_function_like, set_module (1)
 from ..exceptions import AxisError (1)
 from .fromnumeric import * (1)
 from .arrayprint import * (1)
 from ._asarray import * (1)
 from ._ufunc_config import * (1)

shape_base.py (2) from .multiarray import array, asanyarray, normalize_axis_index (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 def _atleast_1d_dispatcher(*arys): (1)
 @array_function_dispatch(_atleast_1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def atleast_1d(*arys): (2)
 def _atleast_2d_dispatcher(*arys): (1)
 @array_function_dispatch(_atleast_2d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def atleast_2d(*arys): (2)
 def _atleast_3d_dispatcher(*arys): (1)
 @array_function_dispatch(_atleast_3d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def atleast_3d(*arys): (2)
 def _arrays_for_stack_dispatcher(arrays): (1)
 def _vhstack_dispatcher(tup, *, dtype=None, casting=None): (1)
 @array_function_dispatch(_vhstack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vstack(tup, *, dtype=None, casting="same_kind"): (2)
 @array_function_dispatch(_vhstack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def hstack(tup, *, dtype=None, casting="same_kind"): (2)
 def _stack_dispatcher(arrays, axis=None, out=None, *, (2)
 dtype=None, casting=None): (1)
 @array_function_dispatch(_stack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def stack(arrays, axis=0, out=None, *, dtype=None, casting="same_kind"): (2)
 def _unstack_dispatcher(x, /, *, axis=None): (1)
 @array_function_dispatch(_unstack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unstack(x, /, *, axis=0): (2)
 _size = getattr(_from_nx.size, '__wrapped__', _from_nx.size) (1)
 _ndim = getattr(_from_nx.ndim, '__wrapped__', _from_nx.ndim) (1)
 _concatenate = getattr(_from_nx.concatenate, (2)
 '__wrapped__', _from_nx.concatenate) (1)
 def _block_format_index(index): (1)
 def _block_check_depths_match(arrays, parent_index=[]): (1)
 def _atleast_nd(a, ndim): (1)
 def _accumulate(values): (1)
 def _concatenate_shapes(shapes, axis): (1)
 def _block_info_recursion(arrays, max_depth, result_ndim, depth=0): (1)
 def _block(arrays, max_depth, result_ndim, depth=0): (1)
 def _block_dispatcher(arrays): (1)
 @array_function_dispatch(_block_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def block(arrays): (2)
 def _block_setup(arrays): (1)
 def _block_slicing(arrays, list_ndim, result_ndim): (1)
 def _block_concatenate(arrays, list_ndim, result_ndim): (1)

fromnumeric.py (6) from . import multiarray as mu (1)
 from . import overrides (1)
 from . import umath as um (1)
 from . import numerictypes as nt (1)
 from .multiarray import asarray, array, asanyarray, concatenate (1)
 _dt_ = nt.sctype2char (1)
 __all__ = [ (1)
 _gentype = types.GeneratorType (1)
 _sum_ = sum (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 def _wrapit(obj, method, *args, **kwds): (1)
 def _wrapfunc(obj, method, *args, **kwds): (1)
 def _wrapreduction(obj, ufunc, method, axis, dtype, out, **kwargs): (1)
 def _wrapreduction_any_all(obj, ufunc, method, axis, out, **kwargs): (1)
 def _take_dispatcher(a, indices, axis=None, out=None, mode=None): (1)
 @array_function_dispatch(_take_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def take(a, indices, axis=None, out=None, mode='raise'): (2)
 def _reshape_dispatcher(a, /, shape=None, order=None, *, newshape=None, (2)
 copy=None): (1)
 @array_function_dispatch(_reshape_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def reshape(a, /, shape=None, order='C', *, newshape=None, copy=None): (2)
 def _choose_dispatcher(a, choices, out=None, mode=None): (1)
 @array_function_dispatch(_choose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def choose(a, choices, out=None, mode='raise'): (2)
 def _repeat_dispatcher(a, repeats, axis=None): (1)
 @array_function_dispatch(_repeat_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def repeat(a, repeats, axis=None): (2)
 def _put_dispatcher(a, ind, v, mode=None): (1)
 @array_function_dispatch(_put_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def put(a, ind, v, mode='raise'): (2)
 def _swapaxes_dispatcher(a, axis1, axis2): (1)
 @array_function_dispatch(_swapaxes_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def swapaxes(a, axis1, axis2): (2)
 def _transpose_dispatcher(a, axes=None): (1)
 @array_function_dispatch(_transpose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def transpose(a, axes=None): (2)
 def _matrix_transpose_dispatcher(x): (1)
 @array_function_dispatch(_matrix_transpose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matrix_transpose(x, /): (2)
 def _partition_dispatcher(a, kth, axis=None, kind=None, order=None): (1)
 @array_function_dispatch(_partition_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def partition(a, kth, axis=-1, kind='introselect', order=None): (2)
 def _argpartition_dispatcher(a, kth, axis=None, kind=None, order=None): (1)
 @array_function_dispatch(_argpartition_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def argpartition(a, kth, axis=-1, kind='introselect', order=None): (2)
 def _sort_dispatcher(a, axis=None, kind=None, order=None, *, stable=None): (1)
 @array_function_dispatch(_sort_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def sort(a, axis=-1, kind=None, order=None, *, stable=None): (2)
 def _argsort_dispatcher(a, axis=None, kind=None, order=None, *, stable=None): (1)
 @array_function_dispatch(_argsort_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def argsort(a, axis=-1, kind=None, order=None, *, stable=None): (2)
 def _argmax_dispatcher(a, axis=None, out=None, *, keepdims=np._NoValue): (1)
 @array_function_dispatch(_argmax_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def argmax(a, axis=None, out=None, *, keepdims=np._NoValue): (2)
 def _argmin_dispatcher(a, axis=None, out=None, *, keepdims=np._NoValue): (1)
 @array_function_dispatch(_argmin_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def argmin(a, axis=None, out=None, *, keepdims=np._NoValue): (2)
 def _searchsorted_dispatcher(a, v, side=None, sorter=None): (1)
 @array_function_dispatch(_searchsorted_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def searchsorted(a, v, side='left', sorter=None): (2)
 def _resize_dispatcher(a, new_shape): (1)
 @array_function_dispatch(_resize_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def resize(a, new_shape): (2)
 def _squeeze_dispatcher(a, axis=None): (1)
 @array_function_dispatch(_squeeze_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def squeeze(a, axis=None): (2)
 def _diagonal_dispatcher(a, offset=None, axis1=None, axis2=None): (1)
 @array_function_dispatch(_diagonal_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diagonal(a, offset=0, axis1=0, axis2=1): (2)
 a, offset=None, axis1=None, axis2=None, dtype=None, out=None): (1)
 def _trace_dispatcher( (1)
 @array_function_dispatch(_trace_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None): (2)
 def _ravel_dispatcher(a, order=None): (1)
 @array_function_dispatch(_ravel_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ravel(a, order='C'): (2)
 def _nonzero_dispatcher(a): (1)
 @array_function_dispatch(_nonzero_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nonzero(a): (2)
 def _shape_dispatcher(a): (1)
 @array_function_dispatch(_shape_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def shape(a): (2)
 def _compress_dispatcher(condition, a, axis=None, out=None): (1)
 @array_function_dispatch(_compress_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def compress(condition, a, axis=None, out=None): (2)
 def _clip_dispatcher(a, a_min=None, a_max=None, out=None, *, min=None, (2)
 max=None, **kwargs): (1)
 @array_function_dispatch(_clip_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def clip(a, a_min=np._NoValue, a_max=np._NoValue, out=None, *, (3)
 min=np._NoValue, max=np._NoValue, **kwargs): (1)
 def _sum_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_sum_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def sum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, (3)
 initial=np._NoValue, where=np._NoValue): (1)
 def _any_dispatcher(a, axis=None, out=None, keepdims=None, *, (2)
 where=np._NoValue): (1)
 @array_function_dispatch(_any_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def any(a, axis=None, out=None, keepdims=np._NoValue, *, where=np._NoValue): (2)
 def _all_dispatcher(a, axis=None, out=None, keepdims=None, *, (2)
 where=None): (1)
 @array_function_dispatch(_all_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def all(a, axis=None, out=None, keepdims=np._NoValue, *, where=np._NoValue): (2)
 def _cumulative_func(x, func, axis, dtype, out, include_initial): (1)
 def _cumulative_prod_dispatcher(x, /, *, axis=None, dtype=None, out=None, (2)
 include_initial=None): (1)
 @array_function_dispatch(_cumulative_prod_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cumulative_prod(x, /, *, axis=None, dtype=None, out=None, (3)
 include_initial=False): (1)
 def _cumulative_sum_dispatcher(x, /, *, axis=None, dtype=None, out=None, (2)
 include_initial=None): (1)
 @array_function_dispatch(_cumulative_sum_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cumulative_sum(x, /, *, axis=None, dtype=None, out=None, (3)
 include_initial=False): (1)
 def _cumsum_dispatcher(a, axis=None, dtype=None, out=None): (1)
 @array_function_dispatch(_cumsum_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cumsum(a, axis=None, dtype=None, out=None): (2)
 def _ptp_dispatcher(a, axis=None, out=None, keepdims=None): (1)
 @array_function_dispatch(_ptp_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ptp(a, axis=None, out=None, keepdims=np._NoValue): (2)
 def _max_dispatcher(a, axis=None, out=None, keepdims=None, initial=None, (2)
 where=None): (1)
 @array_function_dispatch(_max_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def max(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 @array_function_dispatch(_max_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def amax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 def _min_dispatcher(a, axis=None, out=None, keepdims=None, initial=None, (2)
 where=None): (1)
 @array_function_dispatch(_min_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def min(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 @array_function_dispatch(_min_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def amin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 def _prod_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_prod_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def prod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, (3)
 initial=np._NoValue, where=np._NoValue): (1)
 def _cumprod_dispatcher(a, axis=None, dtype=None, out=None): (1)
 @array_function_dispatch(_cumprod_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cumprod(a, axis=None, dtype=None, out=None): (2)
 def _ndim_dispatcher(a): (1)
 @array_function_dispatch(_ndim_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ndim(a): (2)
 def _size_dispatcher(a, axis=None): (1)
 @array_function_dispatch(_size_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def size(a, axis=None): (2)
 def _round_dispatcher(a, decimals=None, out=None): (1)
 @array_function_dispatch(_round_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def round(a, decimals=0, out=None): (2)
 @array_function_dispatch(_round_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def around(a, decimals=0, out=None): (2)
 def _mean_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, *, (2)
 where=None): (1)
 @array_function_dispatch(_mean_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def mean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, *, (3)
 where=np._NoValue): (1)
 def _std_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, (3)
 keepdims=None, *, where=None, mean=None, correction=None): (2)
 @array_function_dispatch(_std_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, *, (3)
 where=np._NoValue, mean=np._NoValue, correction=np._NoValue): (1)
 def _var_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, (3)
 keepdims=None, *, where=None, mean=None, correction=None): (2)
 @array_function_dispatch(_var_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, *, (3)
 where=np._NoValue, mean=np._NoValue, correction=np._NoValue): (1)

_methods.py (4) from numpy._core import umath as um (1)
 from numpy._core.multiarray import asanyarray (1)
 from numpy._core import numerictypes as nt (1)
 from numpy._core import _exceptions (1)
 from numpy._globals import _NoValue (1)
 bool_dt = mu.dtype("bool") (1)
 umr_maximum = um.maximum.reduce (1)
 umr_minimum = um.minimum.reduce (1)
 umr_sum = um.add.reduce (1)
 umr_prod = um.multiply.reduce (1)
 umr_bitwise_count = um.bitwise_count (1)
 umr_any = um.logical_or.reduce (1)
 umr_all = um.logical_and.reduce (1)
 nt.dtype(nt.csingle) : nt.dtype(nt.single), (1)
 nt.dtype(nt.cdouble) : nt.dtype(nt.double), (1)
 _complex_to_float = { (1)
 if nt.dtype(nt.longdouble) != nt.dtype(nt.double): (1)
 def _amax(a, axis=None, out=None, keepdims=False, (2)
 initial=_NoValue, where=True): (1)
 def _amin(a, axis=None, out=None, keepdims=False, (2)
 initial=_NoValue, where=True): (1)
 def _sum(a, axis=None, dtype=None, out=None, keepdims=False, (2)
 initial=_NoValue, where=True): (1)
 def _prod(a, axis=None, dtype=None, out=None, keepdims=False, (2)
 initial=_NoValue, where=True): (1)
 def _any(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): (1)
 def _all(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): (1)
 def _count_reduce_items(arr, axis, keepdims=False, where=True): (1)
 def _clip(a, min=None, max=None, out=None, **kwargs): (1)
 def _mean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): (1)
 def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, (2)
 where=True, mean=None): (1)
 def _std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, (2)
 where=True, mean=None): (1)
 def _ptp(a, axis=None, out=None, keepdims=False): (1)
 def _dump(self, file, protocol=2): (1)
 def _dumps(self, protocol=2): (1)
 def _bitwise_count(a, out=None, *, where=True, casting='same_kind', (2)
 order='K', dtype=None, subok=True): (1)

_ufunc_config.py (1) from .umath import _make_extobj, _get_extobj_dict, _extobj_contextvar (1)

arrayprint.py (2) from .umath import absolute, isinf, isfinite, isnat (1)
 from .multiarray import (array, dragon4_positional, dragon4_scientific, (1)

records.py (4) from contextlib import nullcontext (1)
 from .._utils import set_module (1)
 from . import numeric as sb (1)
 from . import numerictypes as nt (1)
 from .arrayprint import _get_legacy_print_mode (1)

memmap.py (1) from .numeric import uint8, ndarray, dtype (1)

function_base.py (44) from .numeric import result_type, nan, asanyarray, ndim (1)
 __all__ = ['logspace', 'linspace', 'geomspace'] (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 def _linspace_dispatcher(start, stop, num=None, endpoint=None, retstep=None, (3)
 dtype=None, axis=None, *, device=None): (2)
 @array_function_dispatch(_linspace_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, (4)
 axis=0, *, device=None): (2)
 def _logspace_dispatcher(start, stop, num=None, endpoint=None, base=None, (2)
 dtype=None, axis=None): (1)
 @array_function_dispatch(_logspace_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, (3)
 axis=0): (1)
 def _geomspace_dispatcher(start, stop, num=None, endpoint=None, dtype=None, (2)
 axis=None): (1)
 @array_function_dispatch(_geomspace_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0): (2)
 def _needs_add_docstring(obj): (1)
 def _add_docstring(obj, doc, warn_on_python): (1)
 def add_newdoc(place, obj, doc, warn_on_python=True): (1)
 if isinstance(doc, str): (265)
 if "${ARRAY_FUNCTION_LIKE}" in doc: (51)
 _add_docstring(new, doc.strip(), warn_on_python) (51)
 if warn_on_python and not _needs_add_docstring(obj): (265)
 Py_TPFLAGS_HEAPTYPE = 1 << 9 (265)
 if isinstance(obj, (types.FunctionType, types.MethodType, property)): (265)
 if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: (265)
 return True (265)
 try: (265)
 add_docstring(obj, doc) (265)
_add_newdocs.py (258) add_newdoc('numpy._core', 'flatiter', ('base', (1)
 add_newdoc('numpy._core', 'flatiter', ('coords', (1)
 add_newdoc('numpy._core', 'flatiter', ('index', (1)
 add_newdoc('numpy._core', 'flatiter', ('__array__', (1)
 add_newdoc('numpy._core', 'flatiter', ('copy', (1)
 add_newdoc('numpy._core', 'nditer', (2)
 """ (1)
 add_newdoc('numpy._core', 'nditer', ('copy', (1)
 add_newdoc('numpy._core', 'nditer', ('operands', (1)
 add_newdoc('numpy._core', 'nditer', ('debug_print', (1)
 add_newdoc('numpy._core', 'nditer', ('enable_external_loop', (1)
 add_newdoc('numpy._core', 'nditer', ('iternext', (1)
 add_newdoc('numpy._core', 'nditer', ('remove_axis', (1)
 add_newdoc('numpy._core', 'nditer', ('remove_multi_index', (1)
 add_newdoc('numpy._core', 'nditer', ('reset', (1)
 add_newdoc('numpy._core', 'nested_iters', (2)
 """ (1)
 add_newdoc('numpy._core', 'nditer', ('close', (1)
 add_newdoc('numpy._core', 'broadcast', (2)
 """ (1)
 add_newdoc('numpy._core', 'broadcast', ('index', (1)
 add_newdoc('numpy._core', 'broadcast', ('iters', (1)
 add_newdoc('numpy._core', 'broadcast', ('ndim', (1)
 add_newdoc('numpy._core', 'broadcast', ('nd', (1)
 add_newdoc('numpy._core', 'broadcast', ('numiter', (1)
 add_newdoc('numpy._core', 'broadcast', ('shape', (1)
 add_newdoc('numpy._core', 'broadcast', ('size', (1)
 add_newdoc('numpy._core', 'broadcast', ('reset', (1)
 add_newdoc('numpy._core.multiarray', 'array', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'asarray', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'asanyarray', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'ascontiguousarray', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'asfortranarray', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'empty', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'scalar', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'zeros', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'set_typeDict', (2)
 """set_typeDict(dict) (1)
 add_newdoc('numpy._core.multiarray', 'fromstring', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'compare_chararrays', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'fromiter', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'fromfile', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'frombuffer', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'from_dlpack', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'correlate', (2)
 """cross_correlate(a,v, mode=0)""") (1)
 add_newdoc('numpy._core.multiarray', 'arange', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', '_get_ndarray_c_version', (2)
 """_get_ndarray_c_version() (1)
 add_newdoc('numpy._core.multiarray', '_reconstruct', (2)
 """_reconstruct(subtype, shape, dtype) (1)
 add_newdoc('numpy._core.multiarray', 'promote_types', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'c_einsum', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_interface__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_priority__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_struct__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__dlpack__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__dlpack_device__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('base', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('ctypes', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('data', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('dtype', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('imag', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('itemsize', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('flags', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('flat', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('nbytes', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('ndim', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('real', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('shape', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('size', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('strides', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('T', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('mT', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_finalize__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_wrap__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__copy__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__class_getitem__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__deepcopy__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__reduce__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('__setstate__', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('all', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('any', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('argmax', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('argmin', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('argsort', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('argpartition', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('astype', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('byteswap', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('choose', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('clip', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('compress', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('conj', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('conjugate', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('copy', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('cumprod', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('cumsum', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('diagonal', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('dot')) (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('dumps', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('fill', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('flatten', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('getfield', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('item', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('max', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('mean', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('min', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('nonzero', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('prod', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('put', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('ravel', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('repeat', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('reshape', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('resize', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('round', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('searchsorted', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('setfield', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('setflags', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('sort', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('partition', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('squeeze', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('std', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('sum', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('swapaxes', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('take', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('tofile', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('tolist', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('tobytes', """ (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('tostring', r""" (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('trace', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('transpose', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('var', (1)
 add_newdoc('numpy._core.multiarray', 'ndarray', ('view', (1)
 add_newdoc('numpy._core.umath', 'frompyfunc', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'add_docstring', (2)
 """ (1)
 add_newdoc('numpy._core.umath', '_add_newdoc_ufunc', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'get_handler_name', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'get_handler_version', (2)
 """ (1)
 add_newdoc('numpy._core._multiarray_umath', '_array_converter', (2)
 """ (1)
 add_newdoc( (2)
 'numpy._core._multiarray_umath', '_array_converter', ('scalar_input', (1)
 add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('as_arrays', (1)
 add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('result_type', (1)
 add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('wrap', (1)
 add_newdoc('numpy._core.multiarray', '_get_madvise_hugepage', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', '_set_madvise_hugepage', (2)
 """ (1)
 add_newdoc('numpy._core', 'ufunc', (2)
 """ (1)
 add_newdoc('numpy._core', 'ufunc', ('identity', (1)
 add_newdoc('numpy._core', 'ufunc', ('nargs', (1)
 add_newdoc('numpy._core', 'ufunc', ('nin', (1)
 add_newdoc('numpy._core', 'ufunc', ('nout', (1)
 add_newdoc('numpy._core', 'ufunc', ('ntypes', (1)
 add_newdoc('numpy._core', 'ufunc', ('types', (1)
 add_newdoc('numpy._core', 'ufunc', ('signature', (1)
 add_newdoc('numpy._core', 'ufunc', ('reduce', (1)
 add_newdoc('numpy._core', 'ufunc', ('accumulate', (1)
 add_newdoc('numpy._core', 'ufunc', ('reduceat', (1)
 add_newdoc('numpy._core', 'ufunc', ('outer', (1)
 add_newdoc('numpy._core', 'ufunc', ('at', (1)
 add_newdoc('numpy._core', 'ufunc', ('resolve_dtypes', (1)
 add_newdoc('numpy._core', 'ufunc', ('_resolve_dtypes_and_context', (1)
 add_newdoc('numpy._core', 'ufunc', ('_get_strided_loop', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('alignment', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('byteorder', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('char', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('descr', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('fields', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('flags', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('hasobject', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('isbuiltin', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('isnative', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('isalignedstruct', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('itemsize', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('kind', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('metadata', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('name', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('names', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('num', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('shape', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('ndim', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('str', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('subdtype', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('base', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('type', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('__class_getitem__', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('__ge__', (1)
 add_newdoc('numpy._core.multiarray', 'busdaycalendar', ('weekmask', (1)
 add_newdoc('numpy._core.multiarray', 'busdaycalendar', ('holidays', (1)
 add_newdoc('numpy._core.multiarray', 'normalize_axis_index', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'datetime_data', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 """ (1)
 def refer_to_array_attribute(attr, method=True): (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('T', method=False)) (1)
 docstring = """ (50)
 return attr, docstring.format("method" if method else "attribute", attr) (50)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('base', method=False)) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('data', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('dtype', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('flags', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('flat', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('imag', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('itemsize', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('ndim', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('real', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('shape', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('size', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', ('strides', (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('all')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('any')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('argmax')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('argmin')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('argsort')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('astype')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('byteswap')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('choose')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('clip')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('compress')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('conjugate')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('copy')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('cumprod')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('cumsum')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('diagonal')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('dump')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('dumps')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('fill')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('flatten')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('getfield')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('item')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('max')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('mean')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('min')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('nonzero')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('prod')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('put')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('ravel')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('repeat')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('reshape')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('resize')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('round')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('searchsorted')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('setfield')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('setflags')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('sort')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('squeeze')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('std')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('sum')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('swapaxes')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('take')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('tofile')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('tolist')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('tostring')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('trace')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('transpose')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('var')) (1)
 add_newdoc('numpy._core.numerictypes', 'generic', (2)
 refer_to_array_attribute('view')) (1)
 add_newdoc('numpy._core.numerictypes', 'number', ('__class_getitem__', (1)
 add_newdoc('numpy._core.numerictypes', 'number', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'integer', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'signedinteger', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'unsignedinteger', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'inexact', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'floating', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'complexfloating', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'flexible', (2)
 """ (1)
 add_newdoc('numpy._core.numerictypes', 'character', (2)
 """ (1)
 add_newdoc('numpy._core.multiarray', 'StringDType', (2)
 """ (1)

 new = getattr(__import__(place, globals(), {}, [obj]), obj) (264)
 elif isinstance(doc, tuple): (214)
 attr, docstring = doc (214)
 _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) (214)
 doc = overrides.get_array_function_like_doc(new, doc) (12)
overrides.py (12) ARRAY_FUNCTIONS.add(public_api) (12)
 docstring = public_api.__doc__ or docstring_template (12)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (12)

 except Exception: (6)
 pass (6)
_add_newdocs.py (6) add_newdoc('numpy._core.multiarray', 'ndarray', ('dump', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('newbyteorder', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('__le__', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('__gt__', (1)
 add_newdoc('numpy._core.multiarray', 'dtype', ('__lt__', (1)
 add_newdoc('numpy._core.multiarray', 'busdaycalendar', (2)
 """ (1)


_machar.py (1) class MachAr: (2)
 """ (1)
 def __init__(self, float_conv=float,int_conv=int, (2)
 float_to_float=float, (1)
 float_to_str=lambda v:'%24.16e' % v, (1)
 title='Python floating point number'): (1)
 def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title): (1)
 def __str__(self): (1)
 if __name__ == '__main__': (1)

getlimits.py (3) from ._machar import MachAr (1)
 from . import numerictypes as ntypes (1)
 from .numeric import array, inf, nan (1)

_add_newdocs_scalars.py (2) from numpy._core import numerictypes as _numerictypes (1)
 from numpy._core.function_base import add_newdoc (1)
 def numeric_type_aliases(aliases): (1)
 possible_aliases = numeric_type_aliases([ (1)
 def type_aliases_gen(): (1)
 return list(type_aliases_gen()) (1)
 for alias, doc in aliases: (14)
 try: (14)
 alias_type = getattr(_numerictypes, alias) (14)
 yield (alias_type, alias, doc) (13)

_internal.py (1) try: (1)
 import ctypes (1)

_endian.py (1) _array_type = type(Array) (1)
 def _other_endian(typ): (1)
 class _swapped_meta: (2)
 def __setattr__(self, attrname, value): (1)
 class _swapped_struct_meta(_swapped_meta, type(Structure)): pass (2)
 class _swapped_union_meta(_swapped_meta, type(Union)): pass (2)
 if sys.byteorder == "little": (1)
 _OTHER_ENDIAN = "__ctype_be__" (1)
 LittleEndianStructure = Structure (1)
 class BigEndianStructure(Structure, metaclass=_swapped_struct_meta): (2)
 """Structure with big endian byte order""" (1)
 __slots__ = () (1)
 _swappedbytes_ = None (1)
 LittleEndianUnion = Union (1)
 class BigEndianUnion(Union, metaclass=_swapped_union_meta): (2)
 """Union with big endian byte order""" (1)
 __slots__ = () (1)
 _swappedbytes_ = None (1)

_array_utils_impl.py (2) from numpy._core.numeric import normalize_axis_tuple, normalize_axis_index (1)
 from numpy._utils import set_module (1)
 __all__ = ["byte_bounds", "normalize_axis_tuple", "normalize_axis_index"] (1)
 @set_module("numpy.lib.array_utils") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def byte_bounds(a): (2)

mixins.py (1) __all__ = ['NDArrayOperatorsMixin'] (1)
 def _disables_array_ufunc(obj): (1)
 def _binary_method(ufunc, name): (1)
 def _reflected_binary_method(ufunc, name): (1)
 def _inplace_binary_method(ufunc, name): (1)
 def _numeric_methods(ufunc, name): (1)
 def _unary_method(ufunc, name): (1)
 class NDArrayOperatorsMixin: (2)
 """Mixin defining all operator special methods using __array_ufunc__. (1)
 __slots__ = () (1)
 __lt__ = _binary_method(um.less, 'lt') (1)
 def func(self, other): (20)
 func.__name__ = '__{}__'.format(name) (20)
 return func (20)
 __le__ = _binary_method(um.less_equal, 'le') (1)
 __eq__ = _binary_method(um.equal, 'eq') (1)
 __ne__ = _binary_method(um.not_equal, 'ne') (1)
 __gt__ = _binary_method(um.greater, 'gt') (1)
 __ge__ = _binary_method(um.greater_equal, 'ge') (1)
 __add__, __radd__, __iadd__ = _numeric_methods(um.add, 'add') (1)
 return (_binary_method(ufunc, name), (26)
 _reflected_binary_method(ufunc, name), (13)
 def func(self, other): (14)
 func.__name__ = '__r{}__'.format(name) (14)
 return func (14)
 _inplace_binary_method(ufunc, name)) (13)
 def func(self, other): (13)
 func.__name__ = '__i{}__'.format(name) (13)
 return func (13)
 __sub__, __rsub__, __isub__ = _numeric_methods(um.subtract, 'sub') (1)
 __mul__, __rmul__, __imul__ = _numeric_methods(um.multiply, 'mul') (1)
 __matmul__, __rmatmul__, __imatmul__ = _numeric_methods( (2)
 um.matmul, 'matmul') (1)
 __truediv__, __rtruediv__, __itruediv__ = _numeric_methods( (2)
 um.true_divide, 'truediv') (1)
 __floordiv__, __rfloordiv__, __ifloordiv__ = _numeric_methods( (2)
 um.floor_divide, 'floordiv') (1)
 __mod__, __rmod__, __imod__ = _numeric_methods(um.remainder, 'mod') (1)
 __divmod__ = _binary_method(um.divmod, 'divmod') (1)
 __rdivmod__ = _reflected_binary_method(um.divmod, 'divmod') (1)
 __pow__, __rpow__, __ipow__ = _numeric_methods(um.power, 'pow') (1)
 __lshift__, __rlshift__, __ilshift__ = _numeric_methods( (2)
 um.left_shift, 'lshift') (1)
 __rshift__, __rrshift__, __irshift__ = _numeric_methods( (2)
 um.right_shift, 'rshift') (1)
 __and__, __rand__, __iand__ = _numeric_methods(um.bitwise_and, 'and') (1)
 __xor__, __rxor__, __ixor__ = _numeric_methods(um.bitwise_xor, 'xor') (1)
 __or__, __ror__, __ior__ = _numeric_methods(um.bitwise_or, 'or') (1)
 __neg__ = _unary_method(um.negative, 'neg') (1)
 def func(self): (4)
 func.__name__ = '__{}__'.format(name) (4)
 return func (4)
 __pos__ = _unary_method(um.positive, 'pos') (1)
 __abs__ = _unary_method(um.absolute, 'abs') (1)
 __invert__ = _unary_method(um.invert, 'invert') (1)

_utils_impl.py (2) from numpy._utils import set_module (1)
 import numpy as np (1)

_npyio_impl.py (3) from ._datasource import DataSource (1)
 from numpy._core.multiarray import packbits, unpackbits (1)
 from numpy._core._multiarray_umath import _load_from_filelike (1)
 from numpy._core.overrides import finalize_array_function_like, set_module (1)
 from ._iotools import ( (1)
 __all__ = [ (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 class BagObj: (2)
 """ (1)
 def __init__(self, obj): (1)
 def __getattribute__(self, key): (1)
 def __dir__(self): (1)
 def zipfile_factory(file, *args, **kwargs): (1)
 @set_module('numpy.lib.npyio') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class NpzFile(Mapping): (2)
 """ (1)
 zip = None (1)
 fid = None (1)
 _MAX_REPR_ARRAY_COUNT = 5 (1)
 def __init__(self, fid, own_fid=False, allow_pickle=False, (3)
 pickle_kwargs=None, *, (1)
 max_header_size=format._MAX_HEADER_SIZE): (1)
 def __enter__(self): (1)
 def __exit__(self, exc_type, exc_value, traceback): (1)
 def close(self): (1)
 def __del__(self): (1)
 def __iter__(self): (1)
 def __len__(self): (1)
 def __getitem__(self, key): (1)
 def __contains__(self, key): (1)
 def __repr__(self): (1)
 def get(self, key, default=None, /): (1)
 def items(self): (1)
 def keys(self): (1)
 def values(self): (1)
<frozen abc> (1) (1)
 (1)
 (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, (4)
 encoding='ASCII', *, max_header_size=format._MAX_HEADER_SIZE): (2)
 def _save_dispatcher(file, arr, allow_pickle=None, fix_imports=None): (1)
 @array_function_dispatch(_save_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def save(file, arr, allow_pickle=True, fix_imports=np._NoValue): (2)
 def _savez_dispatcher(file, *args, allow_pickle=True, **kwds): (1)
 @array_function_dispatch(_savez_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def savez(file, *args, allow_pickle=True, **kwds): (2)
 def _savez_compressed_dispatcher(file, *args, allow_pickle=True, **kwds): (1)
 @array_function_dispatch(_savez_compressed_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def savez_compressed(file, *args, allow_pickle=True, **kwds): (2)
 def _savez(file, args, kwds, compress, allow_pickle=True, pickle_kwargs=None): (1)
 def _ensure_ndmin_ndarray_check_param(ndmin): (1)
 def _ensure_ndmin_ndarray(a, *, ndmin: int): (1)
 _loadtxt_chunksize = 50000 (1)
 def _check_nonneg_int(value, name="argument"): (1)
 def _preprocess_comments(iterable, comments, encoding): (1)
 _loadtxt_chunksize = 50000 (1)
 def _read(fname, *, delimiter=',', comment='#', quote='"', (2)
 imaginary_unit='j', usecols=None, skiplines=0, (1)
 max_rows=None, converters=None, ndmin=None, unpack=False, (1)
 dtype=np.float64, encoding=None): (1)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def loadtxt(fname, dtype=float, comments='#', delimiter=None, (4)
 converters=None, skiprows=0, usecols=None, unpack=False, (1)
 ndmin=0, encoding=None, max_rows=None, *, quotechar=None, (2)
 like=None): (1)
 _loadtxt_with_like = array_function_dispatch()(loadtxt) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def _savetxt_dispatcher(fname, X, fmt=None, delimiter=None, newline=None, (2)
 header=None, footer=None, comments=None, (1)
 encoding=None): (1)
 @array_function_dispatch(_savetxt_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (10)
 if args[i][:1] in ['', '.']: (9)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (10)
 if args[i][:1] in ['', '.']: (9)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', (3)
 footer='', comments='# ', encoding=None): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def fromregex(file, regexp, dtype, encoding=None): (2)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def genfromtxt(fname, dtype=float, comments='#', delimiter=None, (4)
 skip_header=0, skip_footer=0, converters=None, (1)
 missing_values=None, filling_values=None, usecols=None, (1)
 names=None, excludelist=None, (1)
 deletechars=''.join(sorted(NameValidator.defaultdeletechars)), (1)
 replace_space='_', autostrip=False, case_sensitive=True, (1)
 defaultfmt="f%i", unpack=None, usemask=False, loose=True, (1)
 invalid_raise=True, max_rows=None, encoding=None, (1)
 *, ndmin=0, like=None): (1)
 _genfromtxt_with_like = array_function_dispatch()(genfromtxt) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def recfromtxt(fname, **kwargs): (1)
 def recfromcsv(fname, **kwargs): (1)

_datasource.py (1) _open = open (1)
 def _check_mode(mode, encoding, newline): (1)
 class _FileOpeners: (2)
 """ (1)
 def __init__(self): (1)
 def _load(self): (1)
 def keys(self): (1)
 def __getitem__(self, key): (1)
 _file_openers = _FileOpeners() (1)
 self._loaded = False (1)
 self._file_openers = {None: open} (1)
 def open(path, mode='r', destpath=os.curdir, encoding=None, newline=None): (1)
 @set_module('numpy.lib.npyio') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class DataSource: (2)
 """ (1)
 def __init__(self, destpath=os.curdir): (1)
 def __del__(self): (1)
 def _iszip(self, filename): (1)
 def _iswritemode(self, mode): (1)
 def _splitzipext(self, filename): (1)
 def _possible_names(self, filename): (1)
 def _isurl(self, path): (1)
 def _cache(self, path): (1)
 def _findfile(self, path): (1)
 def abspath(self, path): (1)
 def _sanitize_relative_path(self, path): (1)
 def exists(self, path): (1)
 def open(self, path, mode='r', encoding=None, newline=None): (1)
 class Repository (DataSource): (2)
 """ (1)
 def __init__(self, baseurl, destpath=os.curdir): (1)
 def __del__(self): (1)
 def _fullpath(self, path): (1)
 def _findfile(self, path): (1)
 def abspath(self, path): (1)
 def exists(self, path): (1)
 def open(self, path, mode='r', encoding=None, newline=None): (1)
 def listdir(self): (1)

_iotools.py (1) def _decode_line(line, encoding=None): (1)
 def _is_string_like(obj): (1)
 def _is_bytes_like(obj): (1)
 def has_nested_fields(ndtype): (1)
 def flatten_dtype(ndtype, flatten_base=False): (1)
 class LineSplitter: (2)
 """ (1)
 def autostrip(self, method): (1)
 def __init__(self, delimiter=None, comments='#', autostrip=True, (2)
 encoding=None): (1)
 def _delimited_splitter(self, line): (1)
 def _fixedwidth_splitter(self, line): (1)
 def _variablewidth_splitter(self, line): (1)
 def __call__(self, line): (1)
 class NameValidator: (2)
 """ (1)
 defaultexcludelist = ['return', 'file', 'print'] (1)
 defaultdeletechars = set(r"""~!@#$%^&*()-=+~\|]}[{';: /?.>,<""") (1)
 def __init__(self, excludelist=None, deletechars=None, (2)
 case_sensitive=None, replace_space='_'): (1)
 def validate(self, names, defaultfmt="f%i", nbfields=None): (1)
 def __call__(self, names, defaultfmt="f%i", nbfields=None): (1)
 def str2bool(value): (1)
 class ConverterError(Exception): (2)
 """ (1)
 pass (1)
 class ConverterLockError(ConverterError): (2)
 """ (1)
 pass (1)
 class ConversionWarning(UserWarning): (2)
 """ (1)
 pass (1)
 class StringConverter: (2)
 """ (1)
 _mapper = [(nx.bool, str2bool, False), (2)
 (nx.int_, int, -1),] (1)
 if nx.dtype(nx.int_).itemsize < nx.dtype(nx.int64).itemsize: (1)
 _mapper.extend([(nx.float64, float, nx.nan), (2)
 (nx.complex128, complex, nx.nan + 0j), (1)
 (nx.longdouble, nx.longdouble, nx.nan), (1)
 (nx.integer, int, -1), (1)
 (nx.floating, float, nx.nan), (1)
 (nx.complexfloating, complex, nx.nan + 0j), (1)
 (nx.str_, asunicode, '???'), (1)
 (nx.bytes_, asbytes, '???'), (1)
 @classmethod (2)
 def _getdtype(cls, val): (2)
 @classmethod (2)
 def _getsubdtype(cls, val): (2)
 @classmethod (2)
 def _dtypeortype(cls, dtype): (2)
 @classmethod (2)
 def upgrade_mapper(cls, func, default=None): (2)
 @classmethod (2)
 def _find_map_entry(cls, dtype): (2)
 def __init__(self, dtype_or_func=None, default=None, missing_values=None, (2)
 locked=False): (1)
 def _loose_call(self, value): (1)
 def _strict_call(self, value): (1)
 def __call__(self, value): (1)
 def _do_upgrade(self): (1)
 def upgrade(self, value): (1)
 def iterupgrade(self, value): (1)
 def update(self, func, default=None, testing_value=None, (2)
 missing_values='', locked=False): (1)
 def easy_dtype(ndtype, names=None, defaultfmt="f%i", **validationargs): (1)

_type_check_impl.py (2) import numpy._core.numeric as _nx (1)
 from ._ufunclike_impl import isneginf, isposinf (1)

_index_tricks_impl.py (2) import numpy._core.numeric as _nx (1)
 from numpy.lib.stride_tricks import as_strided (1)
 from numpy.lib._function_base_impl import diff (1)

defmatrix.py (2) import numpy._core.numeric as N (1)
 def _convert_from_string(data): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def asmatrix(data, dtype=None): (2)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class matrix(N.ndarray): (2)
 """ (1)
 __array_priority__ = 10.0 (1)
 def __new__(subtype, data, dtype=None, copy=True): (1)
 def __array_finalize__(self, obj): (1)
 def __getitem__(self, index): (1)
 def __mul__(self, other): (1)
 def __rmul__(self, other): (1)
 def __imul__(self, other): (1)
 def __pow__(self, other): (1)
 def __ipow__(self, other): (1)
 def __rpow__(self, other): (1)
 def _align(self, axis): (1)
 def _collapse(self, axis): (1)
 def tolist(self): (1)
 def sum(self, axis=None, dtype=None, out=None): (1)
 def squeeze(self, axis=None): (1)
 def flatten(self, order='C'): (1)
 def mean(self, axis=None, dtype=None, out=None): (1)
 def std(self, axis=None, dtype=None, out=None, ddof=0): (1)
 def var(self, axis=None, dtype=None, out=None, ddof=0): (1)
 def prod(self, axis=None, dtype=None, out=None): (1)
 def any(self, axis=None, out=None): (1)
 def all(self, axis=None, out=None): (1)
 def max(self, axis=None, out=None): (1)
 def argmax(self, axis=None, out=None): (1)
 def min(self, axis=None, out=None): (1)
 def argmin(self, axis=None, out=None): (1)
 def ptp(self, axis=None, out=None): (1)
 @property (2)
 def I(self): (2)
 @property (2)
 def A(self): (2)
 @property (2)
 def A1(self): (2)
 def ravel(self, order='C'): (1)
 @property (2)
 def T(self): (2)
 @property (2)
 def H(self): (2)
 getT = T.fget (1)
 getA = A.fget (1)
 getA1 = A1.fget (1)
 getH = H.fget (1)
 getI = I.fget (1)
 def _from_string(str, gdict, ldict): (1)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def bmat(obj, ldict=None, gdict=None): (2)

typing.py (1) import collections.abc (1)
 import copyreg (1)
 import functools (1)
 import operator (1)
 import sys (1)
 import types (1)
 from types import WrapperDescriptorType, MethodWrapperType, MethodDescriptorType, GenericAlias (1)
types.py (1) if name == 'CapsuleType': (1)
 raise AttributeError(f"module {__name__!r} has no attribute {name!r}") (1)

 from _typing import ( (1)

_linalg.py (4) from numpy._core import ( (1)
 from numpy._globals import _NoValue (1)
 from numpy.lib._twodim_base_impl import triu, eye (1)
 from numpy._typing import NDArray (1)
 class EigResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 eigenvalues: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 eigenvectors: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (3)
 if not allow_special_forms: (3)
 invalid_generic_forms += (ClassVar,) (3)
 if is_argument: (3)
 invalid_generic_forms += (Final,) (3)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 if (isinstance(arg, _GenericAlias) and (3)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (3)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)
 assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class EighResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 eigenvalues: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 eigenvectors: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (3)
 if not allow_special_forms: (3)
 invalid_generic_forms += (ClassVar,) (3)
 if is_argument: (3)
 invalid_generic_forms += (Final,) (3)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 if (isinstance(arg, _GenericAlias) and (3)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (3)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)
 assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class QRResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 Q: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 R: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (3)
 if not allow_special_forms: (3)
 invalid_generic_forms += (ClassVar,) (3)
 if is_argument: (3)
 invalid_generic_forms += (Final,) (3)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 if (isinstance(arg, _GenericAlias) and (3)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (3)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)
 assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class SlogdetResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 sign: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 logabsdet: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (3)
 if not allow_special_forms: (3)
 invalid_generic_forms += (ClassVar,) (3)
 if is_argument: (3)
 invalid_generic_forms += (Final,) (3)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (3)
 if arg is None: (3)
 if isinstance(arg, str): (3)
 return arg (3)
 if (isinstance(arg, _GenericAlias) and (3)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (3)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)
 assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class SVDResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 U: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 S: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (1)
 if not allow_special_forms: (1)
 invalid_generic_forms += (ClassVar,) (1)
 if is_argument: (1)
 invalid_generic_forms += (Final,) (1)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (1)
 if arg is None: (1)
 if isinstance(arg, str): (1)
 return arg (1)
 if (isinstance(arg, _GenericAlias) and (1)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (1)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)

 Vh: NDArray[Any] (1)
typing.py (1) msg = "Parameters to generic types must be types." (1)
 arg = _type_check(arg, msg, is_argument=True) (1)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 return arg (1)
 if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or (1)
 (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): (1)
 return arg (1)
 assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (4)
 if field_name in ns: (3)
 elif default_names: (3)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (4)
 for n, t in types} (5)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (5)
 if allow_special_forms and arg in (ClassVar, Final): (3)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (3)
 if type(arg) is tuple: (3)
 return arg (3)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (5)
 if type(name) is not str: (4)
 if not name.isidentifier(): (4)
 if _iskeyword(name): (4)
 seen = set() (1)
 for name in field_names: (4)
 if name.startswith('_') and not rename: (3)
 if name in seen: (3)
 seen.add(name) (3)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (5)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (4)
 doc = _sys.intern(f'Alias for field number {index}') (3)
 class_namespace[name] = _tuplegetter(index, doc) (3)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy.linalg' (1)
 fortran_int = intc (1)
 @set_module('numpy.linalg') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class LinAlgError(ValueError): (2)
 """ (1)
 def _raise_linalgerror_singular(err, flag): (1)
 def _raise_linalgerror_nonposdef(err, flag): (1)
 def _raise_linalgerror_eigenvalues_nonconvergence(err, flag): (1)
 def _raise_linalgerror_svd_nonconvergence(err, flag): (1)
 def _raise_linalgerror_lstsq(err, flag): (1)
 def _raise_linalgerror_qr(err, flag): (1)
 def _makearray(a): (1)
 def isComplexType(t): (1)
 _real_types_map = {single: single, (2)
 double: double, (1)
 csingle: single, (1)
 cdouble: double} (1)
 _complex_types_map = {single: csingle, (2)
 double: cdouble, (1)
 csingle: csingle, (1)
 cdouble: cdouble} (1)
 def _realType(t, default=double): (1)
 def _complexType(t, default=cdouble): (1)
 def _commonType(*arrays): (1)
 def _to_native_byte_order(*arrays): (1)
 def _assert_2d(*arrays): (1)
 def _assert_stacked_2d(*arrays): (1)
 def _assert_stacked_square(*arrays): (1)
 def _assert_finite(*arrays): (1)
 def _is_empty_2d(arr): (1)
 def transpose(a): (1)
 def _tensorsolve_dispatcher(a, b, axes=None): (1)
 @array_function_dispatch(_tensorsolve_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tensorsolve(a, b, axes=None): (2)
 def _solve_dispatcher(a, b): (1)
 @array_function_dispatch(_solve_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def solve(a, b): (2)
 def _tensorinv_dispatcher(a, ind=None): (1)
 @array_function_dispatch(_tensorinv_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tensorinv(a, ind=2): (2)
 def _unary_dispatcher(a): (1)
 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def inv(a): (2)
 def _matrix_power_dispatcher(a, n): (1)
 @array_function_dispatch(_matrix_power_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matrix_power(a, n): (2)
 def _cholesky_dispatcher(a, /, *, upper=None): (1)
 @array_function_dispatch(_cholesky_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cholesky(a, /, *, upper=False): (2)
 def _outer_dispatcher(x1, x2): (1)
 @array_function_dispatch(_outer_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def outer(x1, x2, /): (2)
 def _qr_dispatcher(a, mode=None): (1)
 @array_function_dispatch(_qr_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def qr(a, mode='reduced'): (2)
 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def eigvals(a): (2)
 def _eigvalsh_dispatcher(a, UPLO=None): (1)
 @array_function_dispatch(_eigvalsh_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def eigvalsh(a, UPLO='L'): (2)
 def _convertarray(a): (1)
 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def eig(a): (2)
 @array_function_dispatch(_eigvalsh_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def eigh(a, UPLO='L'): (2)
 def _svd_dispatcher(a, full_matrices=None, compute_uv=None, hermitian=None): (1)
 @array_function_dispatch(_svd_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def svd(a, full_matrices=True, compute_uv=True, hermitian=False): (2)
 def _svdvals_dispatcher(x): (1)
 @array_function_dispatch(_svdvals_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def svdvals(x, /): (2)
 def _cond_dispatcher(x, p=None): (1)
 @array_function_dispatch(_cond_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cond(x, p=None): (2)
 def _matrix_rank_dispatcher(A, tol=None, hermitian=None, *, rtol=None): (1)
 @array_function_dispatch(_matrix_rank_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matrix_rank(A, tol=None, hermitian=False, *, rtol=None): (2)
 def _pinv_dispatcher(a, rcond=None, hermitian=None, *, rtol=None): (1)
 @array_function_dispatch(_pinv_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def pinv(a, rcond=None, hermitian=False, *, rtol=_NoValue): (2)
 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def slogdet(a): (2)
 @array_function_dispatch(_unary_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def det(a): (2)
 def _lstsq_dispatcher(a, b, rcond=None): (1)
 @array_function_dispatch(_lstsq_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def lstsq(a, b, rcond=None): (2)
 def _multi_svd_norm(x, row_axis, col_axis, op): (1)
 def _norm_dispatcher(x, ord=None, axis=None, keepdims=None): (1)
 @array_function_dispatch(_norm_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def norm(x, ord=None, axis=None, keepdims=False): (2)
 def _multidot_dispatcher(arrays, *, out=None): (1)
 @array_function_dispatch(_multidot_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def multi_dot(arrays, *, out=None): (2)
 def _multi_dot_three(A, B, C, out=None): (1)
 def _multi_dot_matrix_chain_order(arrays, return_costs=False): (1)
 def _multi_dot(arrays, order, i, j, out=None): (1)
 def _diagonal_dispatcher(x, /, *, offset=None): (1)
 @array_function_dispatch(_diagonal_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diagonal(x, /, *, offset=0): (2)
 def _trace_dispatcher(x, /, *, offset=None, dtype=None): (1)
 @array_function_dispatch(_trace_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def trace(x, /, *, offset=0, dtype=None): (2)
 def _cross_dispatcher(x1, x2, /, *, axis=None): (1)
 @array_function_dispatch(_cross_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def cross(x1, x2, /, *, axis=-1): (2)
 def _matmul_dispatcher(x1, x2, /): (1)
 @array_function_dispatch(_matmul_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matmul(x1, x2, /): (2)
 def _tensordot_dispatcher(x1, x2, /, *, axes=None): (1)
 @array_function_dispatch(_tensordot_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tensordot(x1, x2, /, *, axes=2): (2)
 tensordot.__doc__ = _core_tensordot.__doc__ (1)
 def _matrix_transpose_dispatcher(x): (1)
 @array_function_dispatch(_matrix_transpose_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matrix_transpose(x, /): (2)
 matrix_transpose.__doc__ = _core_matrix_transpose.__doc__ (1)
 def _matrix_norm_dispatcher(x, /, *, keepdims=None, ord=None): (1)
 @array_function_dispatch(_matrix_norm_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def matrix_norm(x, /, *, keepdims=False, ord="fro"): (2)
 def _vector_norm_dispatcher(x, /, *, axis=None, keepdims=None, ord=None): (1)
 @array_function_dispatch(_vector_norm_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vector_norm(x, /, *, axis=None, keepdims=False, ord=2): (2)
 def _vecdot_dispatcher(x1, x2, /, *, axis=None): (1)
 @array_function_dispatch(_vecdot_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vecdot(x1, x2, /, *, axis=-1): (2)

_twodim_base_impl.py (2) from numpy._core import iinfo (1)
 from numpy.lib._stride_tricks_impl import broadcast_to (1)
 __all__ = [ (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 i1 = iinfo(int8) (1)
getlimits.py (1) try: (1)
 self.dtype = numeric.dtype(int_type) (1)
 self.kind = self.dtype.kind (1)
 self.bits = self.dtype.itemsize * 8 (1)
 self.key = "%s%d" % (self.kind, self.bits) (1)
 if self.kind not in 'iu': (1)

 i2 = iinfo(int16) (1)
getlimits.py (1) try: (1)
 self.dtype = numeric.dtype(int_type) (1)
 self.kind = self.dtype.kind (1)
 self.bits = self.dtype.itemsize * 8 (1)
 self.key = "%s%d" % (self.kind, self.bits) (1)
 if self.kind not in 'iu': (1)

 i4 = iinfo(int32) (1)
getlimits.py (1) try: (1)
 self.dtype = numeric.dtype(int_type) (1)
 self.kind = self.dtype.kind (1)
 self.bits = self.dtype.itemsize * 8 (1)
 self.key = "%s%d" % (self.kind, self.bits) (1)
 if self.kind not in 'iu': (1)

 def _min_int(low, high): (1)
 def _flip_dispatcher(m): (1)
 @array_function_dispatch(_flip_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def fliplr(m): (2)
 @array_function_dispatch(_flip_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def flipud(m): (2)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def eye(N, M=None, k=0, dtype=float, order='C', *, device=None, like=None): (2)
 _eye_with_like = array_function_dispatch()(eye) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def _diag_dispatcher(v, k=None): (1)
 @array_function_dispatch(_diag_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diag(v, k=0): (2)
 @array_function_dispatch(_diag_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def diagflat(v, k=0): (2)
 @finalize_array_function_like (2)
overrides.py (1) public_api.__doc__ = get_array_function_like_doc(public_api) (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 docstring = public_api.__doc__ or docstring_template (1)
 return docstring.replace("${ARRAY_FUNCTION_LIKE}", array_function_like_doc) (1)
 return public_api (1)

 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def tri(N, M=None, k=0, dtype=float, *, like=None): (2)
 _tri_with_like = array_function_dispatch()(tri) (1)
overrides.py (1) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 co = implementation.__code__ (1)
 last_arg = co.co_argcount + co.co_kwonlyargcount - 1 (1)
 last_arg = co.co_varnames[last_arg] (1)
 if last_arg != "like" or co.co_kwonlyargcount == 0: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def _trilu_dispatcher(m, k=None): (1)
 @array_function_dispatch(_trilu_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tril(m, k=0): (2)
 @array_function_dispatch(_trilu_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def triu(m, k=0): (2)
 def _vander_dispatcher(x, N=None, increasing=None): (1)
 @array_function_dispatch(_vander_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vander(x, N=None, increasing=False): (2)
 def _histogram2d_dispatcher(x, y, bins=None, range=None, density=None, (2)
 weights=None): (1)
 @array_function_dispatch(_histogram2d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def histogram2d(x, y, bins=10, range=None, density=None, weights=None): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def mask_indices(n, mask_func, k=0): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def tril_indices(n, k=0, m=None): (2)
 def _trilu_indices_form_dispatcher(arr, k=None): (1)
 @array_function_dispatch(_trilu_indices_form_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tril_indices_from(arr, k=0): (2)
 @set_module('numpy') (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def triu_indices(n, k=0, m=None): (2)
 @array_function_dispatch(_trilu_indices_form_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def triu_indices_from(arr, k=0): (2)

_nbit_base.py (1) from typing import final (1)
typing.py (1) if attr in {"Pattern", "Match"}: (1)
 elif attr in {"ContextManager", "AsyncContextManager"}: (1)
 elif attr == "_collect_parameters": (1)
 raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") (1)

 @final  # Disallow the creation of arbitrary `NBitBase` subclasses (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy.typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class NBitBase: (2)
 """ (1)
 def __init_subclass__(cls) -> None: (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _256Bit(NBitBase):  # type: ignore[misc] (2)
 pass (1)
 allowed_names = { (8)
 if cls.__name__ not in allowed_names: (8)
 super().__init_subclass__() (8)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _128Bit(_256Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _96Bit(_128Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _80Bit(_96Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _64Bit(_80Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _32Bit(_64Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _16Bit(_32Bit):  # type: ignore[misc] (2)
 pass (1)
 @final (3)
typing.py (1) try: (1)
 f.__final__ = True (1)
 return f (1)

 @set_module("numpy._typing") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class _8Bit(_16Bit):  # type: ignore[misc] (2)
 pass (1)

_array_like.py (1) from ._nbit_base import _32Bit, _64Bit (1)

_ufunc.py (1) _UFunc_Nin1_Nout1 = ufunc (1)
 _UFunc_Nin2_Nout1 = ufunc (1)
 _UFunc_Nin1_Nout2 = ufunc (1)
 _UFunc_Nin2_Nout2 = ufunc (1)
 _GUFunc_Nin2_Nout1 = ufunc (1)

_function_base_impl.py (2) from numpy._core.numeric import ( (1)
 from numpy._core.umath import ( (1)
 from numpy._core.fromnumeric import ( (1)
 from numpy._core.numerictypes import typecodes (1)
 from numpy.lib._twodim_base_impl import diag (1)
 from numpy._core.multiarray import ( (1)
 from numpy._core._multiarray_umath import _array_converter (1)
 from numpy._utils import set_module (1)
 from numpy.lib._histograms_impl import histogram, histogramdd  # noqa: F401 (1)

_histograms_impl.py (1) __all__ = ['histogram', 'histogramdd', 'histogram_bin_edges'] (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 _range = range (1)
 def _ptp(x): (1)
 def _hist_bin_sqrt(x, range): (1)
 def _hist_bin_sturges(x, range): (1)
 def _hist_bin_rice(x, range): (1)
 def _hist_bin_scott(x, range): (1)
 def _hist_bin_stone(x, range): (1)
 def _hist_bin_doane(x, range): (1)
 def _hist_bin_fd(x, range): (1)
 def _hist_bin_auto(x, range): (1)
 _hist_bin_selectors = {'stone': _hist_bin_stone, (2)
 'auto': _hist_bin_auto, (1)
 'doane': _hist_bin_doane, (1)
 'fd': _hist_bin_fd, (1)
 'rice': _hist_bin_rice, (1)
 'scott': _hist_bin_scott, (1)
 'sqrt': _hist_bin_sqrt, (1)
 'sturges': _hist_bin_sturges} (1)
 def _ravel_and_check_weights(a, weights): (1)
 def _get_outer_edges(a, range): (1)
 def _unsigned_subtract(a, b): (1)
 def _get_bin_edges(a, bins, range, weights): (1)
 def _search_sorted_inclusive(a, v): (1)
 def _histogram_bin_edges_dispatcher(a, bins=None, range=None, weights=None): (1)
 @array_function_dispatch(_histogram_bin_edges_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def histogram_bin_edges(a, bins=10, range=None, weights=None): (2)
 a, bins=None, range=None, density=None, weights=None): (1)
 def _histogram_dispatcher( (1)
 @array_function_dispatch(_histogram_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def histogram(a, bins=10, range=None, density=None, weights=None): (2)
 def _histogramdd_dispatcher(sample, bins=None, range=None, density=None, (2)
 weights=None): (1)
 @array_function_dispatch(_histogramdd_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def histogramdd(sample, bins=10, range=None, density=None, weights=None): (2)

_nanfunctions_impl.py (2) from numpy.lib._function_base_impl import _weights_are_valid (1)
 from numpy._core import overrides (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 __all__ = [ (1)
 def _nan_mask(a, out=None): (1)
 def _replace_nan(a, val): (1)
 def _copyto(a, val, mask): (1)
 def _remove_nan_1d(arr1d, second_arr1d=None, overwrite_input=False): (1)
 def _divide_by_count(a, b, out=None): (1)
 def _nanmin_dispatcher(a, axis=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_nanmin_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanmin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 def _nanmax_dispatcher(a, axis=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_nanmax_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanmax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, (3)
 where=np._NoValue): (1)
 def _nanargmin_dispatcher(a, axis=None, out=None, *, keepdims=None): (1)
 @array_function_dispatch(_nanargmin_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanargmin(a, axis=None, out=None, *, keepdims=np._NoValue): (2)
 def _nanargmax_dispatcher(a, axis=None, out=None, *, keepdims=None): (1)
 @array_function_dispatch(_nanargmax_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanargmax(a, axis=None, out=None, *, keepdims=np._NoValue): (2)
 def _nansum_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_nansum_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nansum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, (3)
 initial=np._NoValue, where=np._NoValue): (1)
 def _nanprod_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, (2)
 initial=None, where=None): (1)
 @array_function_dispatch(_nanprod_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanprod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, (3)
 initial=np._NoValue, where=np._NoValue): (1)
 def _nancumsum_dispatcher(a, axis=None, dtype=None, out=None): (1)
 @array_function_dispatch(_nancumsum_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nancumsum(a, axis=None, dtype=None, out=None): (2)
 def _nancumprod_dispatcher(a, axis=None, dtype=None, out=None): (1)
 @array_function_dispatch(_nancumprod_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nancumprod(a, axis=None, dtype=None, out=None): (2)
 def _nanmean_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, (2)
 *, where=None): (1)
 @array_function_dispatch(_nanmean_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanmean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, (3)
 *, where=np._NoValue): (1)
 def _nanmedian1d(arr1d, overwrite_input=False): (1)
 def _nanmedian(a, axis=None, out=None, overwrite_input=False): (1)
 def _nanmedian_small(a, axis=None, out=None, overwrite_input=False): (1)
 a, axis=None, out=None, overwrite_input=None, keepdims=None): (1)
 def _nanmedian_dispatcher( (1)
 @array_function_dispatch(_nanmedian_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValue): (2)
 a, q, axis=None, out=None, overwrite_input=None, (1)
 method=None, keepdims=None, *, weights=None, interpolation=None): (2)
 def _nanpercentile_dispatcher( (2)
 @array_function_dispatch(_nanpercentile_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=np._NoValue, (1)
 def nanpercentile( (3)
 weights=None, (1)
 interpolation=None, (1)
 def _nanquantile_dispatcher(a, q, axis=None, out=None, overwrite_input=None, (3)
 method=None, keepdims=None, *, weights=None, (2)
 interpolation=None): (1)
 @array_function_dispatch(_nanquantile_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=np._NoValue, (1)
 def nanquantile( (3)
 weights=None, (1)
 interpolation=None, (1)
 axis=None, (1)
 out=None, (1)
 overwrite_input=False, (1)
 method="linear", (1)
 keepdims=np._NoValue, (1)
 weights=None, (1)
 def _nanquantile_unchecked( (1)
 axis: int | None = None, (2)
 out=None, (1)
 overwrite_input: bool = False, (2)
 method="linear", (1)
 def _nanquantile_ureduce_func( (6)
 a: np.array, (1)
 q: np.array, (1)
 weights: np.array, (1)
 arr1d, q, overwrite_input=False, method="linear", weights=None, (1)
 def _nanquantile_1d( (1)
 def _nanvar_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, (3)
 keepdims=None, *, where=None, mean=None, (2)
 correction=None): (1)
 @array_function_dispatch(_nanvar_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, (3)
 *, where=np._NoValue, mean=np._NoValue, correction=np._NoValue): (1)
 def _nanstd_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, (3)
 keepdims=None, *, where=None, mean=None, (2)
 correction=None): (1)
 @array_function_dispatch(_nanstd_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (7)
 if args[i][:1] in ['', '.']: (6)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, (3)
 *, where=np._NoValue, mean=np._NoValue, correction=np._NoValue): (1)

_shape_base_impl.py (2) from numpy._core import vstack, atleast_3d (1)
 from numpy._core.numeric import normalize_axis_tuple (1)
 from numpy._core.overrides import set_module (1)
 from numpy._core.shape_base import _arrays_for_stack_dispatcher (1)
 from numpy.lib._index_tricks_impl import ndindex (1)
 from numpy.matrixlib.defmatrix import matrix  # this raises all the right alarm bells (1)
 __all__ = [ (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 def _make_along_axis_idx(arr_shape, indices, axis): (1)
 def _take_along_axis_dispatcher(arr, indices, axis): (1)
 @array_function_dispatch(_take_along_axis_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def take_along_axis(arr, indices, axis): (2)
 def _put_along_axis_dispatcher(arr, indices, values, axis): (1)
 @array_function_dispatch(_put_along_axis_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def put_along_axis(arr, indices, values, axis): (2)
 def _apply_along_axis_dispatcher(func1d, axis, arr, *args, **kwargs): (1)
 @array_function_dispatch(_apply_along_axis_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varargs = co.co_varnames[nargs] (1)
 nargs = nargs + 1 (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 varkw = co.co_varnames[nargs] (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def apply_along_axis(func1d, axis, arr, *args, **kwargs): (2)
 def _apply_over_axes_dispatcher(func, a, axes): (1)
 @array_function_dispatch(_apply_over_axes_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def apply_over_axes(func, a, axes): (2)
 def _expand_dims_dispatcher(a, axis): (1)
 @array_function_dispatch(_expand_dims_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def expand_dims(a, axis): (2)
 @set_module("numpy") (2)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 def row_stack(tup, *, dtype=None, casting="same_kind"): (2)
 row_stack.__doc__ = vstack.__doc__ (1)
 def _column_stack_dispatcher(tup): (1)
 @array_function_dispatch(_column_stack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def column_stack(tup): (2)
 def _dstack_dispatcher(tup): (1)
 @array_function_dispatch(_dstack_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def dstack(tup): (2)
 def _replace_zero_by_x_arrays(sub_arys): (1)
 def _array_split_dispatcher(ary, indices_or_sections, axis=None): (1)
 @array_function_dispatch(_array_split_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def array_split(ary, indices_or_sections, axis=0): (2)
 def _split_dispatcher(ary, indices_or_sections, axis=None): (1)
 @array_function_dispatch(_split_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def split(ary, indices_or_sections, axis=0): (2)
 def _hvdsplit_dispatcher(ary, indices_or_sections): (1)
 @array_function_dispatch(_hvdsplit_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def hsplit(ary, indices_or_sections): (2)
 @array_function_dispatch(_hvdsplit_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def vsplit(ary, indices_or_sections): (2)
 @array_function_dispatch(_hvdsplit_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def dsplit(ary, indices_or_sections): (2)
 def get_array_wrap(*args): (1)
 def _kron_dispatcher(a, b): (1)
 @array_function_dispatch(_kron_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def kron(a, b): (2)
 def _tile_dispatcher(A, reps): (1)
 @array_function_dispatch(_tile_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def tile(A, reps): (2)

_arraysetops_impl.py (1) from numpy._core._multiarray_umath import _array_converter (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 __all__ = [ (1)
 def _ediff1d_dispatcher(ary, to_end=None, to_begin=None): (1)
 @array_function_dispatch(_ediff1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def ediff1d(ary, to_end=None, to_begin=None): (2)
 def _unpack_tuple(x): (1)
 def _unique_dispatcher(ar, return_index=None, return_inverse=None, (3)
 return_counts=None, axis=None, *, equal_nan=None): (2)
 @array_function_dispatch(_unique_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (6)
 if args[i][:1] in ['', '.']: (5)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unique(ar, return_index=False, return_inverse=False, (4)
 return_counts=False, axis=None, *, equal_nan=True): (2)
 def _unique1d(ar, return_index=False, return_inverse=False, (3)
 return_counts=False, *, equal_nan=True, inverse_shape=None, (2)
 axis=None): (1)
 class UniqueAllResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 values: np.ndarray (1)
 indices: np.ndarray (1)
 inverse_indices: np.ndarray (1)
 counts: np.ndarray (1)
typing.py (1) assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (5)
 if field_name in ns: (4)
 elif default_names: (4)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (5)
 for n, t in types} (6)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (6)
 invalid_generic_forms = (Generic, Protocol) (4)
 if not allow_special_forms: (4)
 invalid_generic_forms += (ClassVar,) (4)
 if is_argument: (4)
 invalid_generic_forms += (Final,) (4)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (4)
 if arg is None: (4)
 if isinstance(arg, str): (4)
 return arg (4)
 if (isinstance(arg, _GenericAlias) and (4)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (4)
 if allow_special_forms and arg in (ClassVar, Final): (4)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (4)
 if type(arg) is tuple: (4)
 return arg (4)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (6)
 if type(name) is not str: (5)
 if not name.isidentifier(): (5)
 if _iskeyword(name): (5)
 seen = set() (1)
 for name in field_names: (5)
 if name.startswith('_') and not rename: (4)
 if name in seen: (4)
 seen.add(name) (4)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (6)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (5)
 doc = _sys.intern(f'Alias for field number {index}') (4)
 class_namespace[name] = _tuplegetter(index, doc) (4)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class UniqueCountsResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 values: np.ndarray (1)
 counts: np.ndarray (1)
typing.py (1) assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if arg is None: (2)
 if isinstance(arg, str): (2)
 return arg (2)
 if (isinstance(arg, _GenericAlias) and (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 class UniqueInverseResult(NamedTuple): (2)
typing.py (1) assert NamedTuple in bases (1)
 return (_NamedTuple,) (1)

 values: np.ndarray (1)
 inverse_indices: np.ndarray (1)
typing.py (1) assert _NamedTuple in bases (1)
 for base in bases: (2)
 if base is not _NamedTuple and base is not Generic: (1)
 bases = tuple(tuple if base is _NamedTuple else base for base in bases) (3)
 types = ns.get('__annotations__', {}) (1)
 default_names = [] (1)
 for field_name in types: (3)
 if field_name in ns: (2)
 elif default_names: (2)
 nm_tpl = _make_nmtuple(typename, types.items(), (2)
 defaults=[ns[n] for n in default_names], (1)
 module=ns['__module__']) (1)
 fields = [n for n, t in types] (3)
 for n, t in types} (4)
 types = {n: _type_check(t, f"field {n} annotation must be a type") (4)
 invalid_generic_forms = (Generic, Protocol) (2)
 if not allow_special_forms: (2)
 invalid_generic_forms += (ClassVar,) (2)
 if is_argument: (2)
 invalid_generic_forms += (Final,) (2)
 arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) (2)
 if arg is None: (2)
 if isinstance(arg, str): (2)
 return arg (2)
 if (isinstance(arg, _GenericAlias) and (2)
 if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): (2)
 if allow_special_forms and arg in (ClassVar, Final): (2)
 if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): (2)
 if type(arg) is tuple: (2)
 return arg (2)
 nm_tpl = collections.namedtuple(name, fields, (2)
__init__.py (1) if isinstance(field_names, str): (1)
 field_names = list(map(str, field_names)) (1)
 typename = _sys.intern(str(typename)) (1)
 if rename: (1)
 for name in [typename] + field_names: (4)
 if type(name) is not str: (3)
 if not name.isidentifier(): (3)
 if _iskeyword(name): (3)
 seen = set() (1)
 for name in field_names: (3)
 if name.startswith('_') and not rename: (2)
 if name in seen: (2)
 seen.add(name) (2)
 field_defaults = {} (1)
 if defaults is not None: (1)
 defaults = tuple(defaults) (1)
 if len(defaults) > len(field_names): (1)
 field_defaults = dict(reversed(list(zip(reversed(field_names), (2)
 reversed(defaults))))) (1)
 field_names = tuple(map(_sys.intern, field_names)) (1)
 num_fields = len(field_names) (1)
 arg_list = ', '.join(field_names) (1)
 if num_fields == 1: (1)
 repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')' (4)
 tuple_new = tuple.__new__ (1)
 _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip (1)
 '_tuple_new': tuple_new, (1)
 '__builtins__': {}, (1)
 '__name__': f'namedtuple_{typename}', (1)
 namespace = { (1)
 code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))' (1)
 __new__ = eval(code, namespace) (1)
 __new__.__name__ = '__new__' (1)
 __new__.__doc__ = f'Create new instance of {typename}({arg_list})' (1)
 if defaults is not None: (1)
 __new__.__defaults__ = defaults (1)
 @classmethod (2)
 def _make(cls, iterable): (2)
 _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence ' (1)
 def _replace(self, /, **kwds): (1)
 _replace.__doc__ = (f'Return a new {typename} object replacing specified ' (1)
 def __repr__(self): (1)
 def _asdict(self): (1)
 def __getnewargs__(self): (1)
 __new__, (1)
 _make.__func__, (1)
 _replace, (1)
 __repr__, (1)
 _asdict, (1)
 __getnewargs__, (1)
 for method in ( (7)
 method.__qualname__ = f'{typename}.{method.__name__}' (6)
 '__doc__': f'{typename}({arg_list})', (1)
 '__slots__': (), (1)
 '_fields': field_names, (1)
 '_field_defaults': field_defaults, (1)
 '__new__': __new__, (1)
 '_make': _make, (1)
 '__replace__': _replace, (1)
 '_replace': _replace, (1)
 '__repr__': __repr__, (1)
 '_asdict': _asdict, (1)
 '__getnewargs__': __getnewargs__, (1)
 '__match_args__': field_names, (1)
 class_namespace = { (1)
 for index, name in enumerate(field_names): (3)
 doc = _sys.intern(f'Alias for field number {index}') (2)
 class_namespace[name] = _tuplegetter(index, doc) (2)
 result = type(typename, (tuple,), class_namespace) (1)
 if module is None: (1)
 if module is not None: (1)
 result.__module__ = module (1)
 return result (1)

 defaults=defaults, module=module) (1)
 nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types (1)
 return nm_tpl (1)
 nm_tpl.__bases__ = bases (1)
 if Generic in bases: (1)
 for key, val in ns.items(): (7)
 if key in _prohibited: (6)
 elif key not in _special: (6)
 if key not in nm_tpl._fields: (4)
 setattr(nm_tpl, key, val) (4)
 try: (4)
 set_name = type(val).__set_name__ (4)
 except AttributeError: (4)
 pass (4)
 if Generic in bases: (1)
 return nm_tpl (1)

 def _unique_all_dispatcher(x, /): (1)
 @array_function_dispatch(_unique_all_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unique_all(x): (2)
 def _unique_counts_dispatcher(x, /): (1)
 @array_function_dispatch(_unique_counts_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unique_counts(x): (2)
 def _unique_inverse_dispatcher(x, /): (1)
 @array_function_dispatch(_unique_inverse_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unique_inverse(x): (2)
 def _unique_values_dispatcher(x, /): (1)
 @array_function_dispatch(_unique_values_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def unique_values(x): (2)
 ar1, ar2, assume_unique=None, return_indices=None): (1)
 def _intersect1d_dispatcher( (1)
 @array_function_dispatch(_intersect1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def intersect1d(ar1, ar2, assume_unique=False, return_indices=False): (2)
 def _setxor1d_dispatcher(ar1, ar2, assume_unique=None): (1)
 @array_function_dispatch(_setxor1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def setxor1d(ar1, ar2, assume_unique=False): (2)
 def _in1d_dispatcher(ar1, ar2, assume_unique=None, invert=None, *, (2)
 kind=None): (1)
 @array_function_dispatch(_in1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None): (2)
 def _in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None): (1)
 def _isin_dispatcher(element, test_elements, assume_unique=None, invert=None, (2)
 *, kind=None): (1)
 @array_function_dispatch(_isin_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (5)
 if args[i][:1] in ['', '.']: (4)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def isin(element, test_elements, assume_unique=False, invert=False, *, (3)
 kind=None): (1)
 def _union1d_dispatcher(ar1, ar2): (1)
 @array_function_dispatch(_union1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def union1d(ar1, ar2): (2)
 def _setdiff1d_dispatcher(ar1, ar2, assume_unique=None): (1)
 @array_function_dispatch(_setdiff1d_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def setdiff1d(ar1, ar2, assume_unique=False): (2)

_polynomial_impl.py (4) import numpy._core.numeric as NX (1)
 from numpy._core import overrides (1)
 from numpy.exceptions import RankWarning (1)
 from numpy.lib._twodim_base_impl import diag, vander (1)
 from numpy.lib._function_base_impl import trim_zeros (1)
 from numpy.lib._type_check_impl import iscomplex, real, imag, mintypecode (1)
 from numpy.linalg import eigvals, lstsq, inv (1)
 array_function_dispatch = functools.partial( (2)
 overrides.array_function_dispatch, module='numpy') (1)
 def _poly_dispatcher(seq_of_zeros): (1)
 @array_function_dispatch(_poly_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def poly(seq_of_zeros): (2)
 def _roots_dispatcher(p): (1)
 @array_function_dispatch(_roots_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (2)
 if args[i][:1] in ['', '.']: (1)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def roots(p): (2)
 def _polyint_dispatcher(p, m=None, k=None): (1)
 @array_function_dispatch(_polyint_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (4)
 if args[i][:1] in ['', '.']: (3)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polyint(p, m=1, k=None): (2)
 def _polyder_dispatcher(p, m=None): (1)
 @array_function_dispatch(_polyder_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polyder(p, m=1): (2)
 def _polyfit_dispatcher(x, y, deg, rcond=None, full=None, w=None, cov=None): (1)
 @array_function_dispatch(_polyfit_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (8)
 if args[i][:1] in ['', '.']: (7)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 len(implementation_spec.defaults) != (2)
 len(dispatcher_spec.defaults))): (1)
 if implementation_spec.defaults is not None: (1)
 if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False): (2)
 def _polyval_dispatcher(p, x): (1)
 @array_function_dispatch(_polyval_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polyval(p, x): (2)
 def _binary_op_dispatcher(a1, a2): (1)
 @array_function_dispatch(_binary_op_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polyadd(a1, a2): (2)
 @array_function_dispatch(_binary_op_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polysub(a1, a2): (2)
 @array_function_dispatch(_binary_op_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polymul(a1, a2): (2)
 def _polydiv_dispatcher(u, v): (1)
 @array_function_dispatch(_polydiv_dispatcher) (2)
overrides.py (2) def decorator(implementation): (1)
 return decorator (1)
 if verify: (1)
 if dispatcher is not None: (1)
 verify_matching_signatures(implementation, dispatcher) (1)
 implementation_spec = ArgSpec(*getargspec(implementation)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 dispatcher_spec = ArgSpec(*getargspec(dispatcher)) (1)
_inspect.py (1) if ismethod(func): (1)
 return isinstance(object, types.MethodType) (1)
 if not isfunction(func): (1)
 return isinstance(object, types.FunctionType) (1)
 args, varargs, varkw = getargs(func.__code__) (1)
 if not iscode(co): (1)
 return isinstance(object, types.CodeType) (1)
 nargs = co.co_argcount (1)
 names = co.co_varnames (1)
 args = list(names[:nargs]) (1)
 for i in range(nargs): (3)
 if args[i][:1] in ['', '.']: (2)
 varargs = None (1)
 if co.co_flags & CO_VARARGS: (1)
 varkw = None (1)
 if co.co_flags & CO_VARKEYWORDS: (1)
 return args, varargs, varkw (1)
 return args, varargs, varkw, func.__defaults__ (1)

 if (implementation_spec.args != dispatcher_spec.args or (1)
 implementation_spec.varargs != dispatcher_spec.varargs or (1)
 implementation_spec.keywords != dispatcher_spec.keywords or (1)
 (bool(implementation_spec.defaults) != (2)
 bool(dispatcher_spec.defaults)) or (1)
 (implementation_spec.defaults is not None and (1)
 if implementation_spec.defaults is not None: (1)
 if docs_from_dispatcher: (1)
 public_api = _ArrayFunctionDispatcher(dispatcher, implementation) (1)
 public_api = functools.wraps(implementation)(public_api) (1)
functools.py (1) return partial(update_wrapper, wrapped=wrapped, (2)
 assigned=assigned, updated=updated) (1)
 for attr in assigned: (7)
 try: (6)
 value = getattr(wrapped, attr) (6)
 setattr(wrapper, attr, value) (6)
 for attr in updated: (2)
 getattr(wrapper, attr).update(getattr(wrapped, attr, {})) (1)
 wrapper.__wrapped__ = wrapped (1)
 return wrapper (1)

 if module is not None: (1)
 public_api.__module__ = module (1)
 ARRAY_FUNCTIONS.add(public_api) (1)
 return public_api (1)

 def polydiv(u, v): (2)
 _poly_mat = re.compile(r"\*\*([0-9]*)") (1)
__init__.py (1) return _compile(pattern, flags) (1)
 if isinstance(flags, RegexFlag): (1)
 try: (1)
 return _cache2[type(pattern), pattern, flags] (1)
 except KeyError: (1)
 pass (1)
 key = (type(pattern), pattern, flags) (1)
 p = _cache.pop(key, None) (1)
 if p is None: (1)
 if isinstance(pattern, Pattern): (1)
 if not _compiler.isstring(pattern): (1)
_compiler.py (1) return isinstance(obj, (str, bytes)) (1)

 p = _compiler.compile(pattern, flags) (1)
_compiler.py (1) if isstring(p): (1)
 return isinstance(obj, (str, bytes)) (1)
 pattern = p (1)
 p = _parser.parse(p, flags) (1)
_parser.py (1) source = Tokenizer(str) (1)
 self.istext = isinstance(string, str) (1)
 self.string = string (1)
 if not self.istext: (1)
 self.decoded_string = string (1)
 self.index = 0 (1)
 self.next = None (1)
 self.__next() (1)
 index = self.index (11)
 try: (11)
 char = self.decoded_string[index] (11)
 if char == "\\": (10)
 index += 1 (2)
 try: (2)
 char += self.decoded_string[index] (2)
 self.index = index + 1 (10)
 self.next = char (10)
 if state is None: (1)
 state = State() (1)
 self.flags = 0 (1)
 self.groupdict = {} (1)
 self.groupwidths = [None]  # group 0 (1)
 self.lookbehindgroups = None (1)
 self.grouprefpos = {} (1)
 state.flags = flags (1)
 state.str = str (1)
 p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0) (1)
 items = [] (2)
 itemsappend = items.append (2)
 sourcematch = source.match (2)
 start = source.tell() (2)
 return self.index - len(self.next or '') (5)
 while True: (2)
 itemsappend(_parse(source, state, verbose, nested + 1, (4)
 not nested and not items)) (2)
 subpattern = SubPattern(state) (2)
 self.state = state (3)
 if data is None: (3)
 data = [] (2)
 self.data = data (3)
 self.width = None (3)
 subpatternappend = subpattern.append (2)
 sourceget = source.get (2)
 sourcematch = source.match (2)
 _len = len (2)
 _ord = ord (2)
 while True: (7)
 this = source.next (7)
 if this is None: (7)
 if this in "|)": (6)
 sourceget() (5)
 this = self.next (8)
 self.__next() (8)
 return this (8)
 if verbose: (5)
 if this[0] == "\\": (5)
 code = _escape(source, this, state) (2)
 code = CATEGORIES.get(escape) (2)
 if code: (2)
 code = ESCAPES.get(escape) (2)
 if code: (2)
 try: (2)
 c = escape[1:2] (2)
 if c == "x": (2)
 elif c == "u" and source.istext: (2)
 elif c == "U" and source.istext: (2)
 elif c == "N" and source.istext: (2)
 elif c == "0": (2)
 elif c in DIGITS: (2)
 if len(escape) == 2: (2)
 if c in ASCIILETTERS: (2)
 return LITERAL, ord(escape[1]) (2)
 subpatternappend(code) (2)
 self.data.append(code) (4)
 elif this not in SPECIAL_CHARS: (3)
 elif this == "[": (3)
 elif this in REPEAT_CHARS: (2)
 elif this == ".": (1)
 elif this == "(": (1)
 start = source.tell() - 1 (1)
 capture = True (1)
 atomic = False (1)
 name = None (1)
 add_flags = 0 (1)
 del_flags = 0 (1)
 if sourcematch("?"): (1)
 if char == self.next: (8)
 return False (6)
 if capture: (1)
 try: (1)
 group = state.opengroup(name) (1)
 gid = self.groups (1)
 return len(self.groupwidths) (2)
 self.groupwidths.append(None) (1)
 if self.groups > MAXGROUPS: (1)
 if name is not None: (1)
 return gid (1)
 sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and (1)
 p = _parse_sub(source, state, sub_verbose, nested + 1) (1)
 here = source.tell() - 1 (1)
 set = [] (1)
 setappend = set.append (1)
 if source.next == '[': (1)
 negate = sourcematch("^") (1)
 while True: (2)
 this = sourceget() (2)
 if this is None: (2)
 if this == "]" and set: (2)
 elif this[0] == "\\": (1)
 if set and this in '-&~|' and source.next == this: (1)
 code1 = LITERAL, _ord(this) (1)
 if sourcematch("-"): (1)
 self.__next() (2)
 return True (2)
 that = sourceget() (1)
 if that is None: (1)
 if that == "]": (1)
 if that[0] == "\\": (1)
 if that == '-': (1)
 code2 = LITERAL, _ord(that) (1)
 if code1[0] != LITERAL or code2[0] != LITERAL: (1)
 lo = code1[1] (1)
 hi = code2[1] (1)
 if hi < lo: (1)
 setappend((RANGE, (lo, hi))) (1)
 break (1)
 set = _uniq(set) (1)
 return list(dict.fromkeys(items)) (1)
 if _len(set) == 1 and set[0][0] is LITERAL: (1)
 if negate: (1)
 subpatternappend((IN, set)) (1)
 here = source.tell() (1)
 if this == "?": (1)
 elif this == "*": (1)
 min, max = 0, MAXREPEAT (1)
 if subpattern: (1)
 return len(self.data) (4)
 item = subpattern[-1:] (1)
 if isinstance(index, slice): (8)
 return SubPattern(self.state, self.data[index]) (1)
 if not item or item[0][0] is AT: (1)
 return self.data[index] (7)
 if item[0][0] in _REPEATCODES: (1)
 if item[0][0] is SUBPATTERN: (1)
 if sourcematch("?"): (1)
 elif sourcematch("+"): (1)
 subpattern[-1] = (MAX_REPEAT, (min, max, item)) (1)
 self.data[index] = code (1)
 break # end of subpattern (1)
 for i in range(len(subpattern))[::-1]: (6)
 op, av = subpattern[i] (4)
 if op is SUBPATTERN: (4)
 return subpattern (2)
 if not sourcematch("|"): (2)
 break (2)
 if len(items) == 1: (2)
 return items[0] (2)
 if not source.match(")"): (1)
 except IndexError: (1)
 self.next = None (1)
 return (1)
 if group is not None: (1)
 state.closegroup(group, p) (1)
 self.groupwidths[gid] = p.getwidth() (1)
 if self.width is not None: (2)
 lo = hi = 0 (2)
 for op, av in self.data: (4)
 if op is BRANCH: (2)
 elif op is ATOMIC_GROUP: (2)
 elif op is SUBPATTERN: (2)
 elif op in _REPEATCODES: (2)
 i, j = av[2].getwidth() (1)
 elif op in _UNITCODES: (1)
 lo = lo + 1 (1)
 hi = hi + 1 (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (2)
 return self.width (2)
 lo = lo + i * av[0] (1)
 if av[1] == MAXREPEAT and j: (1)
 hi = MAXWIDTH (1)
 if atomic: (1)
 subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p))) (1)
 break # end of pattern (1)
 group, add_flags, del_flags, p = av (1)
 if group is None and not add_flags and not del_flags: (1)
 p.state.flags = fix_flags(str, p.state.flags) (1)
 if isinstance(src, str): (1)
 if flags & SRE_FLAG_LOCALE: (1)
 if not flags & SRE_FLAG_ASCII: (1)
 flags |= SRE_FLAG_UNICODE (1)
 return flags (1)
 if source.next is not None: (1)
 for g in p.state.grouprefpos: (1)
 if flags & SRE_FLAG_DEBUG: (1)
 return p (1)

 code = _code(p, flags) (1)
 flags = p.state.flags | flags (1)
 code = [] (1)
 _compile_info(code, p, flags) (1)
 lo, hi = pattern.getwidth() (1)
_parser.py (1) if self.width is not None: (2)
 lo = hi = 0 (1)
 for op, av in self.data: (4)
 if op is BRANCH: (3)
 elif op is ATOMIC_GROUP: (3)
 elif op is SUBPATTERN: (3)
 elif op in _REPEATCODES: (2)
 elif op in _UNITCODES: (2)
 lo = lo + 1 (2)
 hi = hi + 1 (2)
 i, j = av[-1].getwidth() (1)
 return self.width (1)
 lo = lo + i (1)
 hi = hi + j (1)
 self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH) (1)
 return self.width (1)

 if hi > MAXCODE: (1)
 hi = MAXCODE (1)
 if lo == 0: (1)
 prefix = [] (1)
 prefix_skip = 0 (1)
 charset = [] # not used (1)
 if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE): (1)
 prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags) (1)
 prefix = [] (2)
 prefixappend = prefix.append (2)
 prefix_skip = None (2)
 iscased = _get_iscased(flags) (2)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 return None (2)
 for op, av in pattern.data: (4)
 if op is LITERAL: (4)
 if iscased and iscased(av): (2)
 prefixappend(av) (2)
 elif op is SUBPATTERN: (2)
 group, add_flags, del_flags, p = av (1)
 flags1 = _combine_flags(flags, add_flags, del_flags) (1)
 if add_flags & TYPE_FLAGS: (2)
 return (flags | add_flags) & ~del_flags (2)
 if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE: (1)
 prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1) (1)
 break (1)
 return prefix, prefix_skip, False (2)
 if prefix_skip is None: (1)
 if group is not None: (1)
 prefix_skip = len(prefix) (1)
 prefix.extend(prefix1) (1)
 if not got_all: (1)
 break (1)
 if not prefix: (1)
 emit = code.append (1)
 emit(INFO) (1)
 skip = len(code); emit(0) (1)
 mask = 0 (1)
 if prefix: (1)
 mask = SRE_INFO_PREFIX (1)
 if prefix_skip is None and got_all: (1)
 emit(mask) (1)
 if lo < MAXCODE: (1)
 emit(lo) (1)
 emit(hi) (1)
 if prefix: (1)
 emit(len(prefix)) # length (1)
 if prefix_skip is None: (1)
 emit(prefix_skip) # skip (1)
 code.extend(prefix) (1)
 code.extend(_generate_overlap_table(prefix)) (1)
 table = [0] * len(prefix) (1)
 for i in range(1, len(prefix)): (2)
 idx = table[i - 1] (1)
 while prefix[i] != prefix[idx]: (1)
 table[i] = idx + 1 (1)
 return table (1)
 code[skip] = len(code) - skip (1)
 _compile(code, p.data, flags) (1)
 emit = code.append (3)
 _len = len (3)
 LITERAL_CODES = _LITERAL_CODES (3)
 REPEATING_CODES = _REPEATING_CODES (3)
 SUCCESS_CODES = _SUCCESS_CODES (3)
 ASSERT_CODES = _ASSERT_CODES (3)
 iscased = None (3)
 tolower = None (3)
 fixes = None (3)
 if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE: (3)
 for op, av in pattern: (8)
_parser.py (4) if isinstance(index, slice): (4)
 return self.data[index] (4)

 if op in LITERAL_CODES: (5)
 if not flags & SRE_FLAG_IGNORECASE: (2)
 emit(op) (2)
 emit(av) (2)
 elif op is IN: (3)
 elif op is ANY: (2)
 elif op in REPEATING_CODES: (2)
 elif op is SUBPATTERN: (1)
 group, add_flags, del_flags, p = av (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2) (1)
 _compile(code, p, _combine_flags(flags, add_flags, del_flags)) (1)
 if _simple(av[2]): (1)
 if len(p) != 1: (1)
_parser.py (1) return len(self.data) (1)

 op, av = p[0] (1)
_parser.py (1) if isinstance(index, slice): (1)
 return self.data[index] (1)

 if op is SUBPATTERN: (1)
 return op in _UNIT_CODES (1)
 emit(REPEATING_CODES[op][2]) (1)
 skip = _len(code); emit(0) (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 _compile(code, av[2], flags) (1)
 charset, hascased = _optimize_charset(av, iscased, tolower, fixes) (1)
 out = [] (1)
 tail = [] (1)
 charmap = bytearray(256) (1)
 hascased = False (1)
 for op, av in charset: (2)
 while True: (1)
 try: (1)
 if op is LITERAL: (1)
 elif op is RANGE: (1)
 r = range(av[0], av[1]+1) (1)
 if fixup: # IGNORECASE and not LOCALE (1)
 for i in r: (11)
 charmap[i] = 1 (10)
 break (1)
 runs = [] (1)
 q = 0 (1)
 while True: (2)
 p = charmap.find(1, q) (2)
 if p < 0: (2)
 if len(runs) >= 2: (1)
 q = charmap.find(0, p) (1)
 if q < 0: (1)
 runs.append((p, q)) (1)
 break (1)
 if runs is not None: (1)
 for p, q in runs: (2)
 if q - p == 1: (1)
 out.append((RANGE, (p, q - 1))) (1)
 out += tail (1)
 if hascased or len(out) < len(charset): (1)
 return charset, hascased (1)
 if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE: (1)
 elif not hascased: (1)
 emit(IN) (1)
 skip = _len(code); emit(0) (1)
 _compile_charset(charset, flags, code) (1)
 emit = code.append (1)
 for op, av in charset: (2)
 emit(op) (1)
 if op is NEGATE: (1)
 elif op is LITERAL: (1)
 elif op is RANGE or op is RANGE_UNI_IGNORE: (1)
 emit(av[0]) (1)
 emit(av[1]) (1)
 emit(FAILURE) (1)
 code[skip] = _len(code) - skip (1)
 emit(SUCCESS) (1)
 code[skip] = _len(code) - skip (1)
 if group: (1)
 emit(MARK) (1)
 emit((group-1)*2+1) (1)
 code.append(SUCCESS) (1)
 return code (1)
 if flags & SRE_FLAG_DEBUG: (1)
 groupindex = p.state.groupdict (1)
 indexgroup = [None] * p.state.groups (1)
_parser.py (1) return len(self.groupwidths) (1)

 for k, i in groupindex.items(): (1)
 return _sre.compile( (2)
 pattern, flags | p.state.flags, code, (1)
 p.state.groups-1, (1)
_parser.py (1) return len(self.groupwidths) (1)

 groupindex, tuple(indexgroup) (1)

 if flags & DEBUG: (1)
enum.py (1) other_value = self._get_value(other) (1)
 if isinstance(flag, self.__class__): (3)
 elif self._member_type_ is not object and isinstance(flag, self._member_type_): (2)
 return flag (2)
 if other_value is NotImplemented: (1)
 for flag in self, other: (3)
 if self._get_value(flag) is None: (2)
 return flag._value_ (1)
 value = self._value_ (1)
 return self.__class__(value & other_value) (1)
 if cls._member_map_: (1)
 if names is not _not_given: (1)
 return cls.__new__(cls, value) (1)
 if type(value) is cls: (1)
 try: (1)
 return cls._value2member_map_[value] (1)

 if len(_cache) >= _MAXCACHE: (1)
 _cache[key] = p (1)
 if len(_cache2) >= _MAXCACHE2: (1)
 _cache2[key] = p (1)
 return p (1)

 def _raise_power(astr, wrap=70): (1)
 @set_module('numpy') (3)
__init__.py (2) def decorator(func): (1)
 return decorator (1)
 if module is not None: (1)
 func.__module__ = module (1)
 return func (1)

 class poly1d: (2)
 """ (1)
 __hash__ = None (1)
 @property (2)
 def coeffs(self): (2)
 @coeffs.setter (2)
 def coeffs(self, value): (2)
 @property (2)
 def variable(self): (2)
 @property (2)
 def order(self): (2)
 @property (2)
 def roots(self): (2)
 @property (2)
 def _coeffs(self): (2)
 @_coeffs.setter (2)
 def _coeffs(self, coeffs): (2)
 r = roots (1)
 c = coef = coefficients = coeffs (1)
 o = order (1)
 def __init__(self, c_or_r, r=False, variable=None): (1)
 def __array__(self, t=None, copy=None): (1)
 def __repr__(self): (1)
 def __len__(self): (1)
 def __str__(self): (1)
 def __call__(self, val): (1)
 def __neg__(self): (1)
 def __pos__(self): (1)
 def __mul__(self, other): (1)
 def __rmul__(self, other): (1)
 def __add__(self, other): (1)
 def __radd__(self, other): (1)
 def __pow__(self, val): (1)
 def __sub__(self, other): (1)
 def __rsub__(self, other): (1)
 def __div__(self, other): (1)
 __truediv__ = __div__ (1)
 def __rdiv__(self, other): (1)
 __rtruediv__ = __rdiv__ (1)
 def __eq__(self, other): (1)
 def __ne__(self, other): (1)
 def __getitem__(self, val): (1)
 def __setitem__(self, key, val): (1)
 def __iter__(self): (1)
 def integ(self, m=1, k=0): (1)
 def deriv(self, m=1): (1)
 warnings.simplefilter('always', RankWarning) (1)
warnings.py (1) if action not in {"error", "ignore", "always", "default", "module", "once"}: (1)
 if not isinstance(lineno, int): (1)
 if lineno < 0: (1)
 _add_filter(action, None, category, None, lineno, append=append) (1)
 if not append: (1)
 try: (1)
 filters.remove(item) (1)
 except ValueError: (1)
 pass (1)
 filters.insert(0, item) (1)
 _filters_mutated() (1)


_array_api_info.py (1) class __array_namespace_info__: (2)
 """ (1)
 __module__ = 'numpy' (1)
 def capabilities(self): (1)
 def default_device(self): (1)
 def default_dtypes(self, *, device=None): (1)
 def dtypes(self, *, device=None, kind=None): (1)
 def devices(self): (1)

 (274)
 (274)
 (274)
 (274)
 (42)
 (42)
 (42)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (1)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (4)
 (1)

 a = -0.0 (1)
 anp = np.mean(a) (1)
fromnumeric.py (1) return (a, where, out) (1)
 kwargs = {} (1)
 if keepdims is not np._NoValue: (1)
 if where is not np._NoValue: (1)
 if type(a) is not mu.ndarray: (1)
 try: (1)
 mean = a.mean (1)
 except AttributeError: (1)
 pass (1)
 return _methods._mean(a, axis=axis, dtype=dtype, (3)
_methods.py (1) arr = asanyarray(a) (1)
 is_float16_result = False (1)
 rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where) (1)
 if where is True: (1)
 if axis is None: (1)
 axis = tuple(range(arr.ndim)) (1)
 items = 1 (1)
 for ax in axis: (1)
 items = nt.intp(items) (1)
 return items (1)
 if rcount == 0 if where is True else umr_any(rcount == 0, axis=None): (1)
 if dtype is None: (1)
 if issubclass(arr.dtype.type, (nt.integer, nt.bool)): (1)
 elif issubclass(arr.dtype.type, nt.float16): (1)
 ret = umr_sum(arr, axis, dtype, out, keepdims, where=where) (1)
 if isinstance(ret, mu.ndarray): (1)
 elif hasattr(ret, 'dtype'): (1)
 if is_float16_result: (1)
 ret = ret.dtype.type(ret / rcount) (1)
 return ret (1)

 out=out, **kwargs) (2)

 print(anp) (1)
cp1252.py (1) return codecs.charmap_encode(input,self.errors,encoding_table)[0] (2)